diff --git a/.github/workflows/spring-boot-jersey-starter-ci.yml b/.github/workflows/spring-boot-jersey-starter-ci.yml new file mode 100644 index 00000000..712ad1af --- /dev/null +++ b/.github/workflows/spring-boot-jersey-starter-ci.yml @@ -0,0 +1,51 @@ +name: Spring Boot Jersey Starter CI + +on: + push: + paths: + - 'spring/fluentforms-jersey-spring-boot-**' + - '.github/workflows/spring-boot-jersey-starter-ci.yml' + workflow_dispatch: + +jobs: + build: + name: Java ${{ matrix.java }} build + runs-on: ubuntu-latest + continue-on-error: ${{ matrix.experimental }} + strategy: + fail-fast: true + matrix: + java: [ 21 ] + experimental: [false] + include: + - java: 25 + experimental: true + + steps: + - uses: actions/checkout@v6 + - name: Set up JDK ${{ matrix.java }} + uses: actions/setup-java@v5 + with: + distribution: 'oracle' + java-version: ${{ matrix.java }} + cache: 'maven' + server-id: github # Value of the distributionManagement/repository/id field of the pom.xml + settings-path: ${{ github.workspace }} # location for the settings.xml file + + - name: Build AutoConfigure with Maven + run: mvn -B install -s $GITHUB_WORKSPACE/settings.xml --file spring/fluentforms-jersey-spring-boot-autoconfigure + env: + GITHUB_TOKEN: ${{ github.token }} + + - name: Build AutoConfigure with Maven + if: (github.ref == 'refs/heads/master' || github.ref == 'refs/tags/*') && !matrix.experimental # Only run on main branch or tags and non-experimental + run: mvn -B deploy -s $GITHUB_WORKSPACE/settings.xml --file spring/fluentforms-jersey-spring-boot-autoconfigure + env: + GITHUB_TOKEN: ${{ github.token }} + + - name: Publish Starter to GitHub Packages Apache Maven + if: (github.ref == 'refs/heads/master' || github.ref == 'refs/tags/*') && !matrix.experimental # Only run on main branch or tags and non-experimental + run: mvn -B deploy -s $GITHUB_WORKSPACE/settings.xml --file spring/fluentforms-jersey-spring-boot-starter + env: + GITHUB_TOKEN: ${{ github.token }} + \ No newline at end of file diff --git a/.github/workflows/spring-boot-starter-ci.yml b/.github/workflows/spring-boot-webmvc-starter-ci.yml similarity index 93% rename from .github/workflows/spring-boot-starter-ci.yml rename to .github/workflows/spring-boot-webmvc-starter-ci.yml index 128c17be..6eef6ee8 100644 --- a/.github/workflows/spring-boot-starter-ci.yml +++ b/.github/workflows/spring-boot-webmvc-starter-ci.yml @@ -1,10 +1,10 @@ -name: Spring Boot Starter CI +name: Spring Boot WebMVC Starter CI on: push: paths: - 'spring/fluentforms-spring-boot-**' - - '.github/workflows/spring-boot-starter-ci.yml' + - '.github/workflows/spring-boot-webmvc-starter-ci.yml' workflow_dispatch: jobs: @@ -22,7 +22,7 @@ jobs: experimental: true steps: - - uses: actions/checkout@v5 + - uses: actions/checkout@v6 - name: Set up JDK ${{ matrix.java }} uses: actions/setup-java@v5 with: diff --git a/fluentforms/examples/pom.xml b/fluentforms/examples/pom.xml index b9b34207..623d5372 100644 --- a/fluentforms/examples/pom.xml +++ b/fluentforms/examples/pom.xml @@ -11,6 +11,25 @@ FluentForms Examples Various examples of using the Fluent Forms APIs. + + + + + maven-install-plugin + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + + + + org.osgi diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..a3bd675b --- /dev/null +++ b/pom.xml @@ -0,0 +1,36 @@ + + 4.0.0 + com._4point.aem.fluentforms + fluentforms + pom + 0.0.4-SNAPSHOT + Fluent Forms Spring Boot Starter Projects + + + + fluentforms + rest-services + spring + + + + + + + maven-install-plugin + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + + + + \ No newline at end of file diff --git a/rest-services/it.tests/pom.xml b/rest-services/it.tests/pom.xml index 797bae13..51240d97 100644 --- a/rest-services/it.tests/pom.xml +++ b/rest-services/it.tests/pom.xml @@ -38,6 +38,25 @@ 17 + + + + + maven-install-plugin + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + + + + + + com._4point.aem.fluentforms + fluentforms-jersey-spring-boot-autoconfigure + 0.0.4-SNAPSHOT + FluentForms Jersey AutoConfigure Project + + + 17 + 3.0.5 + 3.0.5 + 0.0.4-SNAPSHOT + 0.0.4-SNAPSHOT + + + 0.0.4-SNAPSHOT + 4.0.0-beta.16 + 1.20.2 + 1.2.3 + + + + + github + 4Point Solutions FluentFormsAPI Apache Maven Packages + https://maven.pkg.github.com/4PointSolutions/FluentFormsAPI + + + + + + github + https://maven.pkg.github.com/4PointSolutions/* + + true + + + + + + + + + org.springframework.boot + spring-boot + + + com.github.ulisesbocchio + jasypt-spring-boot-starter + ${jasypt.spring.boot.version} + + + org.springframework.boot + spring-boot-autoconfigure + compile + + + org.springframework.boot + spring-boot-autoconfigure-processor + true + + + org.springframework.boot + spring-boot-starter-jersey + true + provided + + + com._4point.aem.fluentforms + fluentforms-spring-boot-autoconfigure + ${fluentforms-autoconfigure.version} + + + com._4point.aem + fluentforms.core + ${fluentforms.version} + + + com._4point.aem.docservices + rest-services.client + ${fluentforms.version} + + + com._4point.aem.docservices.rest-services + rest-services.jersey-client + ${fluentforms.version} + + + + org.springframework.boot + spring-boot-starter-test + test + + + com.4point.testing + 4point-hamcrest-matchers + ${fp.hamcrest.matchers.version} + test + + + org.wiremock + wiremock-standalone + ${wiremock.version} + test + + + org.pitest + pitest-junit5-plugin + ${pitest.junit5.maven.plugin.version} + test + + + + + + + + com.github.ulisesbocchio + jasypt-maven-plugin + ${jasypt.maven.plugin.version} + + + org.apache.maven.plugins + maven-source-plugin + + + org.apache.maven.plugins + maven-surefire-plugin + + + + + + + + + + org.pitest + pitest-maven + ${pitest.maven.plugin.version} + + + + + \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAfSubmission.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAfSubmission.java new file mode 100644 index 00000000..e8cba253 --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAfSubmission.java @@ -0,0 +1,379 @@ +package com._4point.aem.fluentforms.spring; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Optional; +import java.util.function.Function; + +import org.glassfish.jersey.client.ChunkedInput; +import org.glassfish.jersey.client.ClientProperties; +import org.glassfish.jersey.media.multipart.BodyPartEntity; +import org.glassfish.jersey.media.multipart.FormDataBodyPart; +import org.glassfish.jersey.media.multipart.FormDataMultiPart; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.ssl.SslBundles; +import org.springframework.util.MultiValueMapAdapter; + +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler; + +import jakarta.ws.rs.Consumes; +import jakarta.ws.rs.InternalServerErrorException; +import jakarta.ws.rs.POST; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.PathParam; +import jakarta.ws.rs.Produces; +import jakarta.ws.rs.client.Client; +import jakarta.ws.rs.client.Entity; +import jakarta.ws.rs.client.WebTarget; +import jakarta.ws.rs.core.Context; +import jakarta.ws.rs.core.GenericType; +import jakarta.ws.rs.core.HttpHeaders; +import jakarta.ws.rs.core.MediaType; +import jakarta.ws.rs.core.MultivaluedMap; +import jakarta.ws.rs.core.Response; + +/** + * Class that handles Adaptive Form Submissions. + * + * This class sets up an endpoint that receives all Adaptive Forms submissions. The processing of these + * submissions can be configured based on the available beans available within the Spring context. + * + * If a bean is provided that implements the AfSubmitProcessor interface, then that bean will be called + * for every Adaptive Form submission. + * + * In the absence of an AfSubmitProcessor bean, then if one or more AfSubmitHandler beans are available, these will + * invoked in order for each Adaptive Form submission. + * + * If no AfSubmitHandler beans are available, then all Adaptive Form submissions will be forwarded on + * to the configured AEM instance. + * + * + * + */ +@Path("/aem") +public class AemProxyJerseyAfSubmission { + private final static Logger logger = LoggerFactory.getLogger(AemProxyJerseyAfSubmission.class); + private static final String CONTENT_FORMS_AF = "content/forms/af/"; + + @Autowired + JerseyAfSubmitProcessor submitProcessor; + + @Path(CONTENT_FORMS_AF + "{remainder : .+}") + @POST + @Consumes(MediaType.MULTIPART_FORM_DATA) + @Produces(MediaType.WILDCARD) + public Response proxySubmitPost(@PathParam("remainder") String remainder, /* @HeaderParam(CorrelationId.CORRELATION_ID_HDR) final String correlationIdHdr,*/ @Context HttpHeaders headers, final FormDataMultiPart inFormData) { + logger.atInfo().addArgument(()->submitProcessor != null ? submitProcessor.getClass().getName() : "null" ).log("Submit proxy called. SubmitProcessor={}"); +// final String correlationId = CorrelationId.generate(correlationIdHdr); +// ProcessingMetadataBuilder pmBuilder = ProcessingMetadata.start(correlationId); + return submitProcessor.processRequest(inFormData, headers, remainder); + } + + /** + * Transforms a FormDataMultiPart object using a set of provided functions. + * + * Accepts incoming form data, in the form of a FormDataMultiPart object and a Map collection of functions. It walks through the + * parts and if it finds a function in the Map with the same name it executes that function on the the data from the corresponding part. + * It accumulates and returns the result in another FormDataMultiPart object. + * + * @param inFormData incoming form data + * @param fieldFunctions set of functions that correspond to specific parts + * @param logger logger for logging messages + * @return + * @throws IOException + */ + private static FormDataMultiPart transformFormData(final FormDataMultiPart inFormData, final Map> fieldFunctions, Logger logger) { + try { + FormDataMultiPart outFormData = new FormDataMultiPart(); + var fields = inFormData.getFields(); + logger.atDebug().log(()->"Found " + fields.size() + " fields"); + + for (var fieldEntry : fields.entrySet()) { + String fieldName = fieldEntry.getKey(); + for (FormDataBodyPart fieldData : fieldEntry.getValue()) { + logger.atDebug().log(()->"Copying '" + fieldName + "' field"); + byte[] fieldBytes = ((BodyPartEntity)fieldData.getEntity()).getInputStream().readAllBytes(); + logger.atTrace().log(()->"Fieldname '" + fieldName + "' is '" + new String(fieldBytes) + "'."); + var fieldFn = fieldFunctions.getOrDefault(fieldName, Function.identity()); // Look for an entry in fieldFunctions table for this field. Return the Identity function if we don't find one. + byte[] modifiedFieldBytes = fieldFn.apply(fieldBytes); + if (modifiedFieldBytes != null) { // If the function returned bytes (if not, then remove that part) + outFormData.field(fieldName, new String(modifiedFieldBytes, StandardCharsets.UTF_8)); // Apply the field function to bytes. + } + } + } + return outFormData; + } catch (IOException e) { + throw new InternalServerErrorException("Error while transforming submission data.", e); + } + } + + /** + * Interface that classes that want to perform low-level processing of all Adaptive Forms submissions. + * + * All Adaptive Form submissions will pass through an AfSubmitProcessor singleton found within the Spring + * context. Normally, this will be one of the provided AfSubmitProcessors (like AfSubmitLocalProcessor or + * AfSubmitAemProxyProcessor), but can be replaced by a user supplied implementation. + * + */ + @FunctionalInterface + public interface JerseyAfSubmitProcessor { + /** + * Processor to process incoming Adaptive Forms submit. + * + * @param inFormData + * incoming form data + * @param headers + * incoming HTTP headers + * @param remainder + * Adaptive Forms location path (relative to /content/forms/af/) + * @return + */ + Response processRequest(final FormDataMultiPart inFormData, HttpHeaders headers, String remainder); + } + + @FunctionalInterface + public interface AfFormDataTransformer { + /** + * If one or more of these are available in the Spring context, they will be run against the incoming + * data before it is processed. + * + * This can be useful when used with the AfSubmitAemProxyProcessor to transform the data before it + * is sent to AEM. + * + * This can be useful when used with the AfSubmitLocalProcessor to capture data from the initial + * Adaptive Form submission that may not normally be passed to the AfSubmitHandler. + * + * @param inFormData + * incoming form data object + * @return + * outgoing form data object + */ + FormDataMultiPart transformFormData(final FormDataMultiPart inFormData); + } + /** + * This processor forwards the Adaptive Form submissions on to AEM for processing by the AEM instance. + * + * This is typically used if the AEM Forms Data model will be used for processing the submission. + * + * This is the default submit processor if no other type of submit processing is configured in the + * Spring context. + * + */ + static class AfSubmitAemProxyProcessor implements JerseyAfSubmitProcessor { + + private final AemConfiguration aemConfig; + private final Client httpClient; + + public AfSubmitAemProxyProcessor(AemConfiguration aemConfig, SslBundles sslBundles) { + this.aemConfig = aemConfig; + this.httpClient = JerseyClientFactory.createClient(sslBundles, aemConfig.sslBundle(), aemConfig.user(), aemConfig.password()); + } + + @Override + public Response processRequest(FormDataMultiPart formSubmission, HttpHeaders headers, String remainder) { + logger.atTrace().addArgument(()->{ String formData = formSubmission.getField("jcr:data").getEntityAs(String.class); + return formData != null ? formData : "null"; + }) + .log("AF Submit Proxy: Data = '{}'"); + + // Transfer to AEM + String contentType = headers.getMediaType().toString(); + String cookie = headers.getHeaderString("cookie"); + WebTarget webTarget = httpClient.target(aemConfig.url()) + .property(ClientProperties.FOLLOW_REDIRECTS, Boolean.FALSE) + .path("/" + CONTENT_FORMS_AF + remainder); + + logger.atDebug().log(()->"Proxying Submit POST request for target '" + webTarget.getUri().toString() + "'."); + Response result = webTarget.request() + .header("cookie", cookie) + .post(Entity.entity(formSubmission , contentType)); + + logger.atDebug().log(()->"AEM Response = " + result.getStatus()); + logger.atDebug().log(()->"AEM Response Location = " + result.getLocation()); + + String aemResponseEncoding = result.getHeaderString("Transfer-Encoding"); + if (aemResponseEncoding != null && aemResponseEncoding.equalsIgnoreCase("chunked")) { + logger.atDebug().log("Returning chunked response from AEM."); + return Response.status(result.getStatus()).entity(new ByteArrayInputStream(transferFromAem(result, logger))) + .type(result.getMediaType()) +// .header(CorrelationId.CORRELATION_ID_HDR, correlationId) + .build(); + } else { + logger.atDebug().log("Returning response from AEM."); + return Response.fromResponse(result) +// .header(CorrelationId.CORRELATION_ID_HDR, correlationId) + .build(); + } + } + + /** + * Transfers a response from AEM and returns it in a byte array. It handles chunked responses. + * + * @param result Response object from AEM + * @param logger Logger for logging any errors/warnings/etc. + * @return + * @throws IOException + */ + private static byte[] transferFromAem(Response result, Logger logger) { + try { + if (logger.isDebugEnabled()) { + logger.debug("AEM Response Mediatype=" + (result.getMediaType() != null ? result.getMediaType().toString(): "null")); + MultivaluedMap headers = result.getHeaders(); + for(Entry> entry : headers.entrySet()) { + String msgLine = "For header '" + entry.getKey() + "', "; + for (Object value : entry.getValue()) { + msgLine += "'" + value.toString() + "' "; + } + logger.debug(msgLine); + } + } + + String aemResponseEncoding = result.getHeaderString("Transfer-Encoding"); + if (aemResponseEncoding != null && aemResponseEncoding.equalsIgnoreCase("chunked")) { + // They've sent back chunked response. + logger.debug("Found a chunked encoding."); + final ChunkedInput chunkedInput = result.readEntity(new GenericType>() {}); + byte[] chunk; + ByteArrayOutputStream buffer = new ByteArrayOutputStream(); + try (buffer) { + while ((chunk = chunkedInput.read()) != null) { + buffer.writeBytes(chunk); + logger.debug("Read chunk from AEM response."); + } + } + + return buffer.toByteArray(); + } else { + return ((InputStream)result.getEntity()).readAllBytes(); + } + } catch (IllegalStateException | IOException e) { + throw new InternalServerErrorException("Error while processing transferring result from AEM.", e); + } + } + + } + + /** + * This processor will process Adaptive Forms submissions locally without sending anything to AEM. + * + * It will invoke one or more AfSubmitHandlers that have been configured in the Spring context. + * + * TODO: Add configuration variable that becomes enum value for FIRST and ALL. FIRST = quit after first handler that canHandle + * ALL - process all handlers that canHandle a request. + * + */ + static class AfSubmitLocalProcessor implements JerseyAfSubmitProcessor { + private final static Logger logger = LoggerFactory.getLogger(AfSubmitLocalProcessor.class); + private static final String REMAINDER_PATH_SUFFIX = "/jcr:content/guideContainer.af.submit.jsp"; + + // Have to implement an internal interface so that Spring does not think there are two available + // AfSubmitProcessors. This wraps an internal AfSubmitAemProxyProcessor that the local processor + // uses to handle requests it chooses to pass on to AEM. + @FunctionalInterface + public interface InternalAfSubmitAemProxyProcessor { + AfSubmitAemProxyProcessor get(); + } + + private final List submissionHandlers; + private final AfSubmitAemProxyProcessor aemProxyProcessor; + + AfSubmitLocalProcessor(List submissionHandlers, InternalAfSubmitAemProxyProcessor aemProxyProcessor) { + this.submissionHandlers = submissionHandlers; + this.aemProxyProcessor = aemProxyProcessor.get(); + logger.atInfo().addArgument(submissionHandlers.size()).log("Found {} available AfSubmissionHandlers."); + if(logger.isDebugEnabled()) { + submissionHandlers.forEach(sh->logger.atDebug().addArgument(sh.getClass().getName()).log(" Found AfSubmissionHandler named '{}'.")); + } + } + + @Override + public Response processRequest(FormDataMultiPart inFormData, HttpHeaders headers, String remainder) { + if (!remainder.endsWith(REMAINDER_PATH_SUFFIX)) { + // If the submission does not end with the expected submission suffix, then just proxy it AEM. + return aemProxyProcessor.processRequest(inFormData, headers, remainder); + } + String formName = determineFormName(remainder); + Optional firstHandler = submissionHandlers.stream() + .filter(sh->canHandle(sh, formName)) + .findFirst(); + + return firstHandler.map(h->processSubmission(h, inFormData, headers, formName)) + .orElseGet(()->errorResponse()); + } + + private Response processSubmission(AfSubmissionHandler handler, FormDataMultiPart inFormData, HttpHeaders headers, String formName) { + logger.atInfo().addArgument(handler.getClass().getName()).log("Calling AfSubmissionHandler={}"); + return formulateResponse(handler.processSubmission(formulateSubmission(inFormData, headers, formName))); + } + + private String determineFormName(String guideContainerPath) { + return guideContainerPath.substring(0, guideContainerPath.length() - REMAINDER_PATH_SUFFIX.length()); + } + + private boolean canHandle(AfSubmissionHandler sh, String formName) { + boolean result = sh.canHandle(formName); + logger.atDebug().addArgument(formName).addArgument(()->sh.getClass().getName()).log("Submission Handler canHandle returned {}. ({})"); + return result; + } + + // Create a AfSubmissionHandler.Submission object from the JAX-RS Request classes. + private AfSubmissionHandler.Submission formulateSubmission(FormDataMultiPart inFormData, HttpHeaders headers, String formName) { + class ExtractedData { + String formData; + String redirectUrl; + }; + final ExtractedData extractedData = new ExtractedData(); + // Extract data some of the parts. + final Map> fieldFunctions = // Create a table of functions that will be called to transform specific fields in the incoming AF submission. + Map.of( + ":redirect", (redirect)->{ extractedData.redirectUrl = new String(redirect, StandardCharsets.UTF_8); return null; }, + "jcr:data", (dataBytes)->{ extractedData.formData = new String(dataBytes, StandardCharsets.UTF_8); return null; } + ); + transformFormData(inFormData, fieldFunctions, logger); + return new AfSubmissionHandler.Submission(extractedData.formData, + formName, + extractedData.redirectUrl, + transferHeaders(headers) + ); + } + + // Transfer headers from JAX-RS construct to Spring construct (in order to keep JAX-RS encapsulated in this class) + private MultiValueMapAdapter transferHeaders(HttpHeaders headers) { + if (logger.isDebugEnabled()) { + headers.getRequestHeaders().forEach((k,v)->logger.atDebug().addArgument(k).addArgument(v.size()).log("Found Http header {} with {} values.")); + } + return new MultiValueMapAdapter(headers.getRequestHeaders()); + } + + // Convert the SubmitResponse object into a JAX-RS Response object. + private Response formulateResponse(AfSubmissionHandler.SubmitResponse submitResponse) { + if (submitResponse instanceof AfSubmissionHandler.SubmitResponse.Response response) { + var builder = response.responseBytes().length > 0 ? Response.ok().entity(response.responseBytes()).type(response.mediaType()) + : Response.noContent(); + return builder.build(); + } else if (submitResponse instanceof AfSubmissionHandler.SubmitResponse.SeeOther redirectFound) { + return Response.seeOther(redirectFound.redirectUrl()).build(); + } else if (submitResponse instanceof AfSubmissionHandler.SubmitResponse.Redirect redirect) { + return Response.temporaryRedirect(redirect.redirectUrl()).build(); + } else { + // This cannot happen, but we need to supply an else until we can turn this code into a switch + // expression in JDK 21. + throw new IllegalStateException("Unexpected SubmitResponse class type '%s', this should never happen!".formatted(submitResponse.getClass().getName())); + } + } + + // Generate an JAX-RS Error response if not AfSubmissionHandler was found. + private Response errorResponse() { + logger.atWarn().log("No applicable AfSubmissionHandler found."); + return Response.status(Response.Status.NOT_FOUND).build(); + } + } +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAutoConfiguration.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAutoConfiguration.java new file mode 100644 index 00000000..c6070e67 --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAutoConfiguration.java @@ -0,0 +1,156 @@ +package com._4point.aem.fluentforms.spring; + +import java.util.List; +import java.util.Map; + +import org.glassfish.jersey.servlet.ServletProperties; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.AutoConfiguration; +import org.springframework.boot.autoconfigure.AutoConfigureBefore; +import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; +import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication; +import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication.Type; +import org.springframework.boot.autoconfigure.jersey.ResourceConfigCustomizer; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.ssl.SslBundles; +import org.springframework.boot.system.JavaVersion; +import org.springframework.context.annotation.Bean; +import org.springframework.core.task.SimpleAsyncTaskExecutor; +import org.springframework.core.task.TaskExecutor; + +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.AfSubmitAemProxyProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.AfSubmitLocalProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.AfSubmitLocalProcessor.InternalAfSubmitAemProxyProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.JerseyAfSubmitProcessor; + +/** + * AutoConfiguration for the Reverse Proxy Library which reverse proxies secondary + * resources (.css, .js, etc.) that the browser will request. These requests are forwarded to AEM. + */ +@AutoConfiguration +@ConditionalOnWebApplication(type=Type.SERVLET) +@ConditionalOnProperty(prefix="fluentforms.rproxy", name="enabled", havingValue="true", matchIfMissing=true ) +@ConditionalOnProperty(prefix="fluentforms.rproxy", name="type", havingValue="jersey", matchIfMissing=true ) +@EnableConfigurationProperties({AemConfiguration.class, AemProxyConfiguration.class}) +@ConditionalOnMissingBean(AemProxyImplemention.class) +@AutoConfigureBefore(AemProxyAutoConfiguration.class) +public class AemProxyJerseyAutoConfiguration { + + /** + * Marker bean to indicate that the Jersey-based AEM Proxy implementation is being used. + * + * @return + */ + @Bean + AemProxyImplemention aemProxyImplemention() { + return new AemProxyImplemention() { + // This is just a marker bean. + }; + } + + /** + * Configures the JAX-RS resources associated with reverse proxying resources and submissions from + * Adaptive Forms. + * + * @param aemConfig + * AEM configuration typically configured using application.properties files. This is + * typically injected by the Spring Framework. + * @param aemProxyConfig + * AEM proxy-specific configuration typically configured using application.properties files. + * This is typically injected by the Spring Framework. + * @param aemProxyTaskExecutor + * @return + * JAX-RS Resource configuration customizer that is used by the spring-jersey starter to configure + * JAX-RS Resources (i.e. endpoints) + */ + @Bean + public ResourceConfigCustomizer afProxyConfigurer(AemConfiguration aemConfig, AemProxyConfiguration aemProxyConfig, @Autowired(required = false) SslBundles sslBundles, TaskExecutor aemProxyTaskExecutor) { + return config->config.register(new AemProxyJerseyEndpoint(aemConfig, aemProxyConfig, sslBundles, aemProxyTaskExecutor)) + .register(new AemProxyJerseyAfSubmission()) + .addProperties(Map.of( + // Turn off Wadl generation (this was interfering with some CORS functionality + "jersey.config.server.wadl.disableWadl", true, + // Set properties to allow Jersey to coexist with Spring MVC + "jersey.config.server.response.setStatusOverSendError", true, + // See https://docs.spring.io/spring-boot/how-to/jersey.html#howto .jersey.alongside-another-web-framework + ServletProperties.FILTER_FORWARD_ON_404, true + )) + ; + } + + /** + * Supply a TaskExecutor for use by the AemProxyEndpoint. This is used to process csrf token requests because they are Chunked. + * + * @return the taskeExecutor that will be used to process csrf token requests. + */ + @Bean + public TaskExecutor aemProxyTaskExecutor() { + var executor = new SimpleAsyncTaskExecutor("AemProxy-"); + // Use virtual threads if available. This will be the default for Java 21 and later. + executor.setVirtualThreads(JavaVersion.getJavaVersion().isEqualOrNewerThan(JavaVersion.TWENTY_ONE)); + return executor; + } + + /** + * Supply a AfSubmitLocalProcessor if the user has not already supplied one *and* there is an + * available AfSubmissionHandler + * + * Basically, a user can supply their own AfSubmitProcessor if they want to process things + * at the JAX-RS Servlet level. I expect this to be an unusual case, most users will want + * to either process things locally using a custom AfSubmissionHandler or the will + * want to forward things to AEM by *not* providing a custom AfSubmissionHandler. + * + * @param submissionHandlers + * List of local submission handlers. This is injected by the Spring Framework. + * @return + * Processor that will call the first submission handler that says that it can + * process this request. + */ + @ConditionalOnMissingBean(JerseyAfSubmitProcessor.class) + @ConditionalOnBean(AfSubmissionHandler.class) + @Bean + public JerseyAfSubmitProcessor localSubmitProcessor(List submissionHandlers, InternalAfSubmitAemProxyProcessor aemProxyProcessor) { + return new AfSubmitLocalProcessor(submissionHandlers, aemProxyProcessor); + } + + /** + * Supply a AfSubmitAemProxyProcessor if the user has not supplied any of the AfSubmit beans. + * + * This is the default processor and it will forward all submissions on to the configured AEM + * instance. + * + * @param aemConfig + * AEM configuration typically configured using application.properties files. This is + * typically injected by the Spring Framework. + * @return + * Processor that forwards all submissions on to AEM. + */ + @ConditionalOnMissingBean({JerseyAfSubmitProcessor.class, AfSubmissionHandler.class}) + @Bean() + public JerseyAfSubmitProcessor aemSubmitProcessor(AemConfiguration aemConfig, @Autowired(required = false) SslBundles sslBundles) { + return new AfSubmitAemProxyProcessor(aemConfig, sslBundles); + } + + /** + * Supply a AfSubmitAemProxyProcessor for use by the localSubmitProcessor. + * + * This is the a processor that will forward all submissions on to the configured AEM + * instance. It is used by the localSubmitProcessor to proxy any requests that aren't + * true submissions (e.g. an internalsubmit). + * + * @param aemConfig + * AEM configuration typically configured using application.properties files. This is + * typically injected by the Spring Framework. + * @return + * Processor that forwards all submissions on to AEM. + */ + @ConditionalOnMissingBean(InternalAfSubmitAemProxyProcessor.class) + @ConditionalOnBean(AfSubmissionHandler.class) + @Bean + public InternalAfSubmitAemProxyProcessor aemProxyProcessor(AemConfiguration aemConfig, @Autowired(required = false) SslBundles sslBundles) { + return ()->new AfSubmitAemProxyProcessor(aemConfig, sslBundles); + } +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyEndpoint.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyEndpoint.java new file mode 100644 index 00000000..84ef323e --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyEndpoint.java @@ -0,0 +1,227 @@ +package com._4point.aem.fluentforms.spring; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.util.function.Function; +import java.util.stream.Collectors; + +import javax.naming.ConfigurationException; + +import org.glassfish.jersey.client.ChunkedInput; +import org.glassfish.jersey.server.ChunkedOutput; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.boot.ssl.SslBundles; +import org.springframework.core.task.TaskExecutor; + +import com._4point.aem.docservices.rest_services.client.helpers.ReplacingInputStream; + +import jakarta.ws.rs.GET; +import jakarta.ws.rs.HeaderParam; +import jakarta.ws.rs.POST; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.PathParam; +import jakarta.ws.rs.client.Client; +import jakarta.ws.rs.client.Entity; +import jakarta.ws.rs.client.WebTarget; +import jakarta.ws.rs.core.GenericType; +import jakarta.ws.rs.core.MediaType; +import jakarta.ws.rs.core.Response; + +/** + * Reverse Proxy Code which reverse proxies secondary resources (.css, .js, etc.) that the browser will request. + * These requests are forwarded to AEM. + * + * This code relies on Eclipse Jersey and expects that the spring-boo-starter-jersey is included in the project. + * + * It assumes that the application that generated the Adaptive Form or HTML5 Form inserted /aem in from of any + * AEM links in the AF or HTML5 html code. This task is typically performes using the FluentForms + * StandardFormsFeederUrlFilters.getStandardInputStreamFilter() method and passing that into the call to + * get the AdaptiveForm or HTML5 Form using the FLuentForms libraries. + * + */ +@Path("/aem") +public class AemProxyJerseyEndpoint { + + private final static Logger logger = LoggerFactory.getLogger(AemProxyJerseyEndpoint.class); + + private static final String AEM_APP_PREFIX = "/"; + private Client httpClient; + + private final AemProxyConfiguration aemProxyConfig; + private final AemConfiguration aemConfig; + private final TaskExecutor taskExecutor; + + /** + * + */ + public AemProxyJerseyEndpoint(AemConfiguration aemConfig, AemProxyConfiguration aemProxyConfig, SslBundles sslBundles, TaskExecutor taskExecutor) { + this.aemProxyConfig = aemProxyConfig; + this.aemConfig = aemConfig; + this.httpClient = JerseyClientFactory.createClient(sslBundles, aemConfig.sslBundle(), aemConfig.user(), aemConfig.password()); + this.taskExecutor = taskExecutor; + } + + @Path("libs/granite/csrf/token.json") + @GET + public ChunkedOutput proxyOsgiCsrfToken() throws IOException { + final String path = AEM_APP_PREFIX + "libs/granite/csrf/token.json"; + return getCsrfToken(path); + } + + @Path("lc/libs/granite/csrf/token.json") + @GET + public ChunkedOutput proxyJeeCsrfToken() throws IOException { + final String path = "/lc/libs/granite/csrf/token.json"; + return getCsrfToken(path); + } + + private ChunkedOutput getCsrfToken(final String path) { + logger.atDebug().log("Proxying GET request. CSRF token"); + WebTarget webTarget = httpClient.target(aemConfig.url()) + .path(path); + logger.atDebug().log(()->"Proxying GET request for CSRF token '" + webTarget.getUri().toString() + "'."); + Response result = webTarget.request() + .get(); + + logger.atDebug().log(()->"CSRF token GET response status = " + result.getStatus()); + final ChunkedInput chunkedInput = result.readEntity(new GenericType>() {}); + final ChunkedOutput output = new ChunkedOutput(byte[].class); + + taskExecutor.execute(() -> { + try (result; chunkedInput; output) { + byte[] chunk; + while ((chunk = chunkedInput.read()) != null) { + output.write(chunk); + logger.debug("Returning GET chunk for CSRF token."); + } + logger.debug("Finished GETting chunks for CSRF token."); + } catch (IllegalStateException | IOException e) { + e.printStackTrace(); + } + logger.debug("Exiting Thread."); + }); + + logger.atDebug().log("Returning GET response for CSRF token."); + return output; + } + + + + /** + * This function acts as a reverse proxy for anything under clientlibs. It just forwards + * anything it receives on AEM and then returns the response. + * + * @param remainder + * @return + * @throws ConfigurationException + */ + @Path("{remainder : .+}") + @GET + public Response proxyGet(@PathParam("remainder") String remainder) { + logger.atDebug().log(()->"Proxying GET request. remainder=" + remainder); + WebTarget webTarget = httpClient.target(aemConfig.url()) + .path(AEM_APP_PREFIX + remainder); + logger.atDebug().log(()->"Proxying GET request for target '" + webTarget.getUri().toString() + "'."); + Response result = webTarget.request() + .get(); + if (logger.isDebugEnabled()) { + result.getHeaders().forEach((h, l)->logger.atDebug().log("For " + webTarget.getUri().toString() + ", Header:" + h + "=" + l.stream().map(o->(String)o).collect(Collectors.joining("','", "'", "'")))); + } + + logger.atDebug().log(()->"Returning GET response from target '" + webTarget.getUri().toString() + "' status code=" + result.getStatus() + "."); + Function filter = switch (remainder) { + case "etc.clientlibs/clientlibs/granite/utils.js" -> this::substituteAfBaseLocation; + case "etc.clientlibs/fd/xfaforms/clientlibs/profile.js" -> this::fixTogglesDotJsonLocation; + default -> is -> is; // No filtering needed + }; + return Response.fromResponse(result) + .header("Transfer-Encoding", null) // Remove the Transfer-Encoding header + .entity(filter.apply(result.readEntity(InputStream.class))) + .build(); + } + + /** + * Wraps an InputStream with a wrapper that replaces some code in the Adobe utils.js code. + * + * The detectContextPath function in utils.js has the following line: + * contextPath = result[1]; + * + * This routine replaces it with + * contextPath = FORMSFEEDER_AF_BASE_LOCATION_PROP + result[1]; + * (where FORMSFEEDER_AF_BASE_LOCATION_PROP is whatever value is in the application.properties file) + * + * @param is + * @return + */ + private InputStream substituteAfBaseLocation(InputStream is) { + if (aemProxyConfig.afBaseLocation().isBlank()) { + return is; + } else { + String target = "contextPath = result[1];"; + String replacement = "contextPath = \""+ aemProxyConfig.afBaseLocation() + "\" + result[1];"; + logger.atDebug().log("Altering granite/utils.js to replace '{}' with '{}'", target, replacement); + return new ReplacingInputStream(is, target, replacement); + } + } + + private InputStream fixTogglesDotJsonLocation(InputStream is) { + String target = "\"/etc.clientlibs/toggles.json\""; + String replacement = "\"/aem/etc.clientlibs/toggles.json\""; + logger.atDebug().log("Altering profile.js to replace '{}' with '{}'", target, replacement); + return new ReplacingInputStream(is, target, replacement); + } + + @Path("{remainder : .+}") + @POST + public Response proxyPost(@PathParam("remainder") String remainder, @HeaderParam("Content-Type") String contentType, InputStream in) { + logger.atDebug().log("Proxying POST request. remainder={}", remainder); + WebTarget webTarget = httpClient.target(aemConfig.url()) + .path(AEM_APP_PREFIX + remainder); + logger.atDebug().addArgument(()->webTarget.getUri().toString()) + .addArgument(contentType) + .log(()->"Proxying POST request for target '{}'. ContentType='{}'."); + Response result = webTarget.request() + .post(Entity.entity( + logger.isDebugEnabled() ? debugInput(in, webTarget.getUri().toString()) : in, // if Debug is on, write out information about input stream + contentType != null ? contentType : "application/octet-stream" // supply default content type if it was omitted. + )); + + if (remainder.contains("af.submit.jsp")) { + logger.atDebug().addArgument(()->Boolean.valueOf(result == null).toString()) + .log("result == null is {}."); + MediaType mediaType = result.getMediaType(); + logger.atDebug() + .addArgument(()->webTarget.getUri().toString()) + .addArgument(()->mediaType != null ? mediaType.toString() : "") + .addArgument(()->result.getHeaderString("Transfer-Encoding")) + .log("Returning POST response from target '{}'. contentType='{}'. transfer-encoding='{}'."); + } else { + logger.atDebug() + .addArgument(webTarget.getUri()::toString) + .log("Returning POST response from target '{}'."); + } + + return Response.fromResponse(result).build(); + } + + private InputStream debugInput(InputStream in, String target) { + try { + byte[] inputBytes = in.readAllBytes(); + logger.atDebug() + .log("Proxying POST request for target '{}'. numberOfBytes proxied='{}'.", target, inputBytes.length); + logger.atTrace() + .addArgument(target) + .addArgument(()->new String(inputBytes, StandardCharsets.UTF_8)) + .log("Proxying POST request for target '{}'. input bytes proxied='{}'."); + return new ByteArrayInputStream(inputBytes); + } catch (IOException e) { + logger.atError() + .setCause(e) + .log("Error reading input stream."); + return new ByteArrayInputStream(new byte[0]); + } + } +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/FluentFormsJerseyAutoConfiguration.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/FluentFormsJerseyAutoConfiguration.java new file mode 100644 index 00000000..92aeb4d2 --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/FluentFormsJerseyAutoConfiguration.java @@ -0,0 +1,44 @@ +package com._4point.aem.fluentforms.spring; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.AutoConfiguration; +import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; +import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.ssl.SslBundles; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Lazy; + +import com._4point.aem.docservices.rest_services.client.helpers.Builder.RestClientFactory; +import com._4point.aem.docservices.rest_services.client.jersey.JerseyRestClient; + +import jakarta.ws.rs.client.Client; + +/** + * AutoConfiguration for the FluentForms Rest Services Client library using the Jersey Rest Client. + * + * This class automatically configures a set of beans (one for each AEM service) that can be injected + * into any Spring Boot code. + * + */ +@Lazy +@AutoConfiguration +@EnableConfigurationProperties(AemConfiguration.class) +public class FluentFormsJerseyAutoConfiguration { + + @Configuration(proxyBeanMethods = false) + @ConditionalOnClass(org.glassfish.jersey.client.JerseyClient.class) + public static class JerseyRestClientConfiguration { + + @ConditionalOnProperty(prefix="fluentforms", name="restclient", havingValue="jersey", matchIfMissing=true ) + @ConditionalOnMissingBean + @Bean + public RestClientFactory jerseyRestClientFactory(AemConfiguration aemConfig, @Autowired(required = false) SslBundles sslBundles) { + Client jerseyClient = JerseyClientFactory.createClient(sslBundles, aemConfig.sslBundle()); // Create custom Jersey Client with SSL bundle + return JerseyRestClient.factory(jerseyClient); // Create a RestClientFactory using JerseyClient implementation + } + + } +} diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/JerseyClientFactory.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/JerseyClientFactory.java similarity index 99% rename from spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/JerseyClientFactory.java rename to spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/JerseyClientFactory.java index 602e9fe4..53e770a4 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/JerseyClientFactory.java +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/JerseyClientFactory.java @@ -41,4 +41,4 @@ public static Client createClient(SslBundles sslBundles, String bundleName) { logger.info("Creating default client"); return ClientBuilder.newClient(); } -} +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports new file mode 100644 index 00000000..d489f14e --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports @@ -0,0 +1,2 @@ +com._4point.aem.fluentforms.spring.FluentFormsJerseyAutoConfiguration +com._4point.aem.fluentforms.spring.AemProxyJerseyAutoConfiguration \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAfSubmissionTest.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAfSubmissionTest.java new file mode 100644 index 00000000..90036a46 --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAfSubmissionTest.java @@ -0,0 +1,489 @@ +package com._4point.aem.fluentforms.spring; + +import static com._4point.testing.matchers.javalang.ExceptionMatchers.exceptionMsgContainsAll; +import static com._4point.testing.matchers.jaxrs.ResponseMatchers.doesNotHaveEntity; +import static com._4point.testing.matchers.jaxrs.ResponseMatchers.hasEntityMatching; +import static com._4point.testing.matchers.jaxrs.ResponseMatchers.isStatus; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.allOf; +import static org.hamcrest.Matchers.anyOf; +import static org.hamcrest.Matchers.equalTo; +import static org.junit.jupiter.api.Assertions.assertAll; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.StandardCharsets; +import java.util.List; +import java.util.function.Function; + +import org.glassfish.jersey.client.ClientProperties; +import org.glassfish.jersey.media.multipart.FormDataMultiPart; +import org.glassfish.jersey.media.multipart.MultiPartFeature; +import org.glassfish.jersey.server.ResourceConfig; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.EnumSource; +import org.mockito.Mockito; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.context.SpringBootTest.WebEnvironment; +import org.springframework.boot.test.web.server.LocalServerPort; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.stereotype.Component; + +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler; +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler.SubmitResponse; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.AfSubmitAemProxyProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.AfSubmitLocalProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.AfSubmitLocalProcessor.InternalAfSubmitAemProxyProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.JerseyAfSubmitProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmissionTest.AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest.MockAemProxy; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmissionTest.TestApplication.JerseyConfig; +import com.github.tomakehurst.wiremock.client.WireMock; +import com.github.tomakehurst.wiremock.core.WireMockConfiguration; +import com.github.tomakehurst.wiremock.junit5.WireMockExtension; + +import jakarta.ws.rs.client.ClientBuilder; +import jakarta.ws.rs.client.Entity; +import jakarta.ws.rs.client.WebTarget; +import jakarta.ws.rs.core.HttpHeaders; +import jakarta.ws.rs.core.MediaType; +import jakarta.ws.rs.core.Response; + +/** + * Tests for AemProxyAfSubmissions classes. + * + * Includes inner classes that test the different SubmitProcessor implementations. + * + */ +class AemProxyJerseyAfSubmissionTest { + public static final String AF_TEMPLATE_NAME = "sample00002test"; + private static final String SUBMIT_ADAPTIVE_FORM_SERVICE_PATH = "/aem/content/forms/af/" + AF_TEMPLATE_NAME + "/jcr:content/guideContainer.af.submit.jsp"; + private static final String AEM_SUBMIT_ADAPTIVE_FORM_SERVICE_PATH = SUBMIT_ADAPTIVE_FORM_SERVICE_PATH.substring(4); // Same as above minus "/aem" + public static final MediaType APPLICATION_PDF = new MediaType("application", "pdf"); + private static final String SAMPLE_RESPONSE_BODY = "body"; + + record JakartaRestClient(WebTarget target, URI uri) {}; + + public static JakartaRestClient setUpRestClient(int port) { + var uri = getBaseUri(port); + var target = ClientBuilder.newClient() //newClient(clientConfig) + .property(ClientProperties.FOLLOW_REDIRECTS, Boolean.FALSE) // Disable re-directs so that we can test for "thank you page" redirection. + .register(MultiPartFeature.class) + .target(uri); + return new JakartaRestClient(target, uri); + } + + + /* package */ static FormDataMultiPart mockFormData(String redirect, String data) { + final FormDataMultiPart getPdfForm = new FormDataMultiPart(); + getPdfForm.field("guideContainerPath", "/aem/content/forms/af/" + AF_TEMPLATE_NAME + "/jcr:content/guideContainer") + .field("aemFormComponentPath", "") + .field("_asyncSubmit", "false") + .field("_charset_", "UTF-8") + .field("runtimeLocale", "en") + .field("fileAttachmentMap", "{}") + .field("afSubmissionInfo", "{\"computedMetaInfo\":{},\"stateOverrides\":{},\"signers\":{}}") + .field("TextField1", "TextField1 Contents") + .field("TextField2", "TextField2 Contents") + .field("jcr:data", data) + .field(":redirect", redirect) + .field(":selfUrl", "/aem/content/forms/af/" + AF_TEMPLATE_NAME) + .field("_guideValueMap", "yes") + .field("_guideValuesMap", "{\"textdraw1555538078737\":\"

Sample Form

\\n\",\"TextField1\":\"DFGDFG\",\"TextField2\":\"DFGDG 233\",\"submit\":null}") + .field("_guideAttachments", "") + .field(":cq_csrf_token", "eyJleHAiOjE1NjU2MzUzNzcsImlhdCI6MTU2NTYzNDc3N30.9KB9yPr_mvIfyiwzn5S8mMh-yUzD0-BF99cJR7vW49M"); + return getPdfForm; + } + + private static URI getBaseUri(int port) { + return URI.create("http://localhost:" + port); + } + + // Supporting mock application class that limits the amount of classes to be loaded. + @SpringBootApplication() + @EnableConfigurationProperties({AemConfiguration.class,AemProxyConfiguration.class}) + public static class TestApplication { + public static void main(String[] args) { + SpringApplication.run(TestApplication.class, args); + } + + @Component + public static class JerseyConfig extends ResourceConfig { + } + } + + /** + * Tests the AemAfSubmitProcessor. It utilizes an SSL connection to test the SslBundle code. + * + */ + @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, + classes = {TestApplication.class, JerseyConfig.class, AfSubmitAemProxyProcessor.class}, + properties = { +// "debug", + "fluentforms.aem.servername=" + "localhost", + "fluentforms.aem.port=" + "8502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin", + "fluentforms.aem.useSsl=true", + "spring.ssl.bundle.jks.aem.truststore.location=file:src/test/resources/aemforms.p12", + "spring.ssl.bundle.jks.aem.truststore.password=Pa$$123", + "spring.ssl.bundle.jks.aem.truststore.type=PKCS12" + } + ) + public static class AemProxyAfSubmissionTestWithAemAfSubmitProcessorTest { + + @RegisterExtension + static WireMockExtension wm1 = WireMockExtension.newInstance() + .options(WireMockConfiguration.wireMockConfig().httpsPort(8502) + .httpDisabled(true) + .keystorePath("src/test/resources/aemforms.p12") + .keyManagerPassword("Pa$$123") + .keystorePassword("Pa$$123") + .keystoreType("PKCS12") + ) + .configureStaticDsl(true) // Use with Static DSL + .build(); + + @LocalServerPort + private int port; + + private JakartaRestClient jrc; + + @BeforeEach + public void setUp() throws Exception { + jrc = setUpRestClient(port); + } + + @Test + void test() { + // given + String expectedResponseString = "Dummy Response"; + WireMock.stubFor(WireMock.post(AEM_SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) + .willReturn(WireMock.okForContentType("text/html", expectedResponseString)) + ); + final FormDataMultiPart getPdfForm = mockFormData("foo", "bar"); + + // when + Response response = jrc.target.path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH).request().accept(APPLICATION_PDF) + .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + // then + assertThat(response, allOf(isStatus(Response.Status.OK),hasEntityMatching(equalTo(expectedResponseString.getBytes())))); + WireMock.verify( + WireMock.postRequestedFor(WireMock.urlEqualTo(AEM_SUBMIT_ADAPTIVE_FORM_SERVICE_PATH)) + .withAnyRequestBodyPart(WireMock.aMultipart("jcr:data").withBody(WireMock.equalTo("bar"))) + ); + } + + } + + /** + * Tests the AemLocalSubmitProcessor + * + */ + @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, + classes = {TestApplication.class, JerseyConfig.class, AfSubmitLocalProcessor.class, MockAemProxy.class, + AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest.MockSubmissionProcessor.class, + AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest.MockSubmissionProcessor2.class} + ,properties={ +// "debug", + "logging.level.com._4point.aem.fluentforms.spring=DEBUG" + } + ) + public static class AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest { + private static final String AF_SUBMIT_LOCAL_PROCESSOR_RESPONSE = "AfSubmitLocalProcessor Response"; + + private final static Logger logger = LoggerFactory.getLogger(AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest.class); + + @LocalServerPort + private int port; + + private JakartaRestClient jrc; + + @BeforeEach + public void setUp() throws Exception { + jrc = setUpRestClient(port); + } + + + @Test + void testResponse() { + final FormDataMultiPart getPdfForm = mockFormData("foo1", "bar"); + + Response response = jrc.target + .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) + .request() + .accept(MediaType.TEXT_PLAIN_TYPE) + .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(isStatus(Response.Status.OK),hasEntityMatching(equalTo(AF_SUBMIT_LOCAL_PROCESSOR_RESPONSE.getBytes())))); + } + + @Test + void testRedirect() { + final FormDataMultiPart getPdfForm = mockFormData("foo2", "bar"); + + Response response = jrc.target + .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) + .request() + .accept(MediaType.TEXT_PLAIN_TYPE) + .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(isStatus(Response.Status.TEMPORARY_REDIRECT), doesNotHaveEntity())); + } + + @Test + void testSeeOther() { + final FormDataMultiPart getPdfForm = mockFormData("foo3", "bar"); + + Response response = jrc.target + .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) + .request() + .accept(MediaType.TEXT_PLAIN_TYPE) + .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(isStatus(Response.Status.SEE_OTHER), doesNotHaveEntity())); + } + + @Test + void testProxy() { + final FormDataMultiPart getPdfForm = mockFormData("foo2", "bar"); + + Response response = jrc.target + .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH+"anythingElse") + .request() + .accept(MediaType.TEXT_PLAIN_TYPE) + .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(isStatus(Response.Status.OK), doesNotHaveEntity())); + } + + @Component + public static class MockSubmissionProcessor implements AfSubmissionHandler { + + @Override + public boolean canHandle(String formName) { + logger.atDebug().log(()->"I can handle form name '" + formName + "'!!!!"); + assertEquals(AF_TEMPLATE_NAME, formName); + return true; // Can always handle. + } + + + @Override + public SubmitResponse processSubmission(Submission submission) { + // Validate the arguments passed in. + + assertAll( + ()->assertEquals(AF_TEMPLATE_NAME, submission.formName()), + ()->assertEquals("bar", submission.formData()), + ()->assertThat(submission.redirectUrl(), anyOf(equalTo("foo1"), equalTo("foo2"), equalTo("foo3"))), + ()->assertEquals(MediaType.TEXT_PLAIN, submission.headers().getFirst("accept")), + ()->assertTrue(MediaType.MULTIPART_FORM_DATA_TYPE.isCompatible(MediaType.valueOf(submission.headers().getFirst("content-type")))) + ); + try { + String redirectUrl = submission.redirectUrl(); + return switch(redirectUrl) { + case "foo1" -> new SubmitResponse.Response(AF_SUBMIT_LOCAL_PROCESSOR_RESPONSE.getBytes(), "text/plain"); + case "foo2" -> new SubmitResponse.Redirect(new URI("http://localhost/")); + case "foo3" -> new SubmitResponse.SeeOther(new URI("http://localhost/")); + default -> throw new UnsupportedOperationException("Unexpected value in redirectUrl (%s)".formatted(redirectUrl)); + }; + } catch (URISyntaxException e) { + throw new IllegalStateException("Bad URI -- ", e); + } + } + } + + @Component + public static class MockSubmissionProcessor2 implements AfSubmissionHandler { + + @Override + public boolean canHandle(String formName) { + return false; // Can never handle. + } + + + @Override + public SubmitResponse processSubmission(Submission submission) { + fail("MockSubmissionProcessor2.processSubmission should never be called"); + return null; + } + } + + @Configuration + public static class MockAemProxy { + @Bean() + public InternalAfSubmitAemProxyProcessor aemProxyProcessor() { + AfSubmitAemProxyProcessor mock = Mockito.mock(AfSubmitAemProxyProcessor.class); + Mockito.when(mock.processRequest(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(Response.ok().build()); + return ()->mock; + } + } + } + + /** + * Tests a custom AfSubmitProcessor + * + */ + @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, + classes = {TestApplication.class, JerseyConfig.class, AemProxyAfSubmissionTestWithCustomAfSubmitProcessorTest.MockSubmitProcessor.class} +// ,properties="debug" + ) + public static class AemProxyAfSubmissionTestWithCustomAfSubmitProcessorTest { + + @LocalServerPort + private int port; + + private JakartaRestClient jrc; + + @BeforeEach + public void setUp() throws Exception { + jrc = setUpRestClient(port); + } + + @Test + void test() { + final FormDataMultiPart getPdfForm = mockFormData("foo", "bar"); + + Response response = jrc.target + .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) + .request() + .accept(APPLICATION_PDF) + .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(isStatus(Response.Status.OK), hasEntityMatching(equalTo(SAMPLE_RESPONSE_BODY.getBytes())))); + } + + @Component + public static class MockSubmitProcessor implements JerseyAfSubmitProcessor { + + @Override + public Response processRequest(FormDataMultiPart inFormData, HttpHeaders headers, String remainder) { + return Response.ok().entity(SAMPLE_RESPONSE_BODY).build(); + } + } + } + + public static class SubmitResponseResponseTests { + private static final String SAMPLE_TEXT = "text"; + private static final byte[] SAMPLE_TEXT_BYTES = SAMPLE_TEXT.getBytes(StandardCharsets.UTF_8); + + enum TestScenario { + TEXT("text/plain", SubmitResponse.Response::text), + HTML("text/html", SubmitResponse.Response::html), + JSON("application/json", SubmitResponse.Response::json), + XML("application/xml", SubmitResponse.Response::xml) + ; + final String expectedContentType; + final Function methodUnderTest; + + private TestScenario(String expectedContentType, Function methodUnderTest) { + this.expectedContentType = expectedContentType; + this.methodUnderTest = methodUnderTest; + } + } + + @ParameterizedTest + @EnumSource + void testResponseCreationMethod(TestScenario scenario) { + var result = scenario.methodUnderTest.apply(SAMPLE_TEXT); + assertAll( + ()->assertArrayEquals(SAMPLE_TEXT_BYTES, result.responseBytes()), + ()->assertEquals(scenario.expectedContentType, result.mediaType()) + ); + } + } + + public static class AfSubmissionHandlerTests { + // In this class we test the static convenience methods that generate AfSubmissionHandlers. Since the + // processSubmission logic is one line (and trivial) we don't test it, however we do test the canHandle() + // method generated by the convenience method. + + @ParameterizedTest + @CsvSource({ + "formName, true", + "notFormName, false" + }) + void testcanHandleFormNameEquals(String formNameIn, boolean expectedResult) { + var underTest = AfSubmissionHandler.canHandleFormNameEquals("formName", t->null); + assertEquals(expectedResult, underTest.canHandle(formNameIn)); + } + + @DisplayName("Passing in null should produce a null pointer exception") + @Test + void testcanHandleFormNameEquals_Null() { + NullPointerException ex = assertThrows(NullPointerException.class, ()->AfSubmissionHandler.canHandleFormNameEquals(null, t->null)); + assertThat(ex, exceptionMsgContainsAll("Form Name for submission handler cannot be null")); + } + + @ParameterizedTest + @CsvSource({ + "formName1, true", + "formName2, true", + "notFormName, false" + }) + void testcanHandleFormNameAnyOf(String formNameIn, boolean expectedResult) { + var underTest = AfSubmissionHandler.canHandleFormNameAnyOf(t->null, "formName1", "formName2"); + assertEquals(expectedResult, underTest.canHandle(formNameIn)); + } + + @ParameterizedTest + @CsvSource({ + "formName1, false", + "formName2, false", + "notFormName, false" + }) + void testcanHandleFormNameAnyOf_NoNames(String formNameIn, boolean expectedResult) { + var underTest = AfSubmissionHandler.canHandleFormNameAnyOf(t->null); + assertEquals(expectedResult, underTest.canHandle(formNameIn)); + } + + @ParameterizedTest + @CsvSource({ + "formName1, true", + "formName2, true", + "notFormName, false" + }) + void testcanHandleFormNameAnyOf_List(String formNameIn, boolean expectedResult) { + var underTest = AfSubmissionHandler.canHandleFormNameAnyOf(List.of("formName1", "formName2"), t->null); + assertEquals(expectedResult, underTest.canHandle(formNameIn)); + } + + @ParameterizedTest + @CsvSource({ + "formName1, false", + "formName2, false", + "notFormName, false" + }) + void testcanHandleFormNameAnyOf__List_NoNames(String formNameIn, boolean expectedResult) { + var underTest = AfSubmissionHandler.canHandleFormNameAnyOf(List.of(), t->null); + assertEquals(expectedResult, underTest.canHandle(formNameIn)); + } + + @ParameterizedTest + @CsvSource({ + "formName1, true", + "formName2, true", + "notFormName, false" + }) + void testcanHandleFormNameMatchesRegEx(String formNameIn, boolean expectedResult) { + var underTest = AfSubmissionHandler.canHandleFormNameMatchesRegex("formName.*", t->null); + assertEquals(expectedResult, underTest.canHandle(formNameIn)); + } + } +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAutoConfigurationTest.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAutoConfigurationTest.java new file mode 100644 index 00000000..cfb13982 --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyAutoConfigurationTest.java @@ -0,0 +1,35 @@ +package com._4point.aem.fluentforms.spring; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.jersey.ResourceConfigCustomizer; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest(classes = {com._4point.aem.fluentforms.spring.FluentFormsJerseyAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class}, +properties = { + "fluentforms.aem.servername=localhost", + "fluentforms.aem.port=4502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin)", + }) +class AemProxyJerseyAutoConfigurationTest { + + @Test + void testDocumentFactory(@Autowired ResourceConfigCustomizer afProxyConfigurer) { + assertNotNull(afProxyConfigurer); + } + + @SpringBootApplication + @EnableConfigurationProperties({AemConfiguration.class,AemProxyConfiguration.class}) + public static class TestApplication { + public static void main(String[] args) { + SpringApplication.run(TestApplication.class, args); + } + + } +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyEndpointTest.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyEndpointTest.java new file mode 100644 index 00000000..ae37cd30 --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyJerseyEndpointTest.java @@ -0,0 +1,172 @@ +package com._4point.aem.fluentforms.spring; + +import static com.github.tomakehurst.wiremock.client.WireMock.*; +import static java.util.Objects.requireNonNullElse; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.concurrent.TimeUnit; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.FieldSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.context.SpringBootTest.WebEnvironment; +import org.springframework.boot.test.web.server.LocalServerPort; +import org.springframework.web.client.RestClient; + +import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo; +import com.github.tomakehurst.wiremock.junit5.WireMockTest; + +@WireMockTest(httpPort = AemProxyJerseyEndpointTest.WIREMOCK_PORT) +@SpringBootTest(classes = {com._4point.aem.fluentforms.spring.AemProxyJerseyEndpointTest.TestApplication.class}, +webEnvironment = WebEnvironment.RANDOM_PORT, +properties = { +"fluentforms.aem.servername=localhost", +"fluentforms.aem.port=" + AemProxyJerseyEndpointTest.WIREMOCK_PORT, +"fluentforms.aem.user=ENC(7FgD3ZsSExfUGRYlXNc++6C1upPBURNKq6HouzagnNZW4FsBwFs5+crawv+djhw6)", +"fluentforms.aem.password=ENC(QmQ6iTm/+TOO8U3dDuBzJWH129vReWgYNdgqQwWhjWaQy6j8sMnk2/Auhehmlh3v)", +//"fluentforms.aem.useSsl=true", +"fluentforms.rproxy.af-base-location=" + AemProxyJerseyEndpointTest.AF_BASE_LOCATION, +"jasypt.encryptor.algorithm=PBEWITHHMACSHA512ANDAES_256", +"jasypt.encryptor.password=4Point", +"jasypt.encryptor.iv-generator-classname=org.jasypt.iv.RandomIvGenerator", +"jasypt.encryptor.salt-generator-classname=org.jasypt.salt.RandomSaltGenerator", +"logging.level.com._4point.aem.fluentforms.spring.AemProxyEndpoint=DEBUG" +}) +@Timeout(value = 5, unit = TimeUnit.MINUTES) // Fail tests that take longer than this to prevent hanging. +class AemProxyJerseyEndpointTest { + private final static Logger logger = LoggerFactory.getLogger(AemProxyJerseyEndpointTest.class); + + static final int WIREMOCK_PORT = 5504; + static final String AF_BASE_LOCATION = "/aem"; + + // The following is a string that contains all possible values that may be modified by the AemProxyEndpoint. + private static final String MODIFICATION_TARGETS_FORMAT_STR = """ + 'contextPath = %sresult[1];' + '"%s/etc.clientlibs/toggles.json"' + """; + private static final String MODIFICATION_TARGETS = MODIFICATION_TARGETS_FORMAT_STR.formatted("", ""); + + @LocalServerPort + private int port; + + private RestClient restClient; + + @BeforeEach + void setup(WireMockRuntimeInfo wmRuntimeInfo) { + restClient = RestClient.builder() + .baseUrl(("http://localhost:%d" + AF_BASE_LOCATION).formatted(port)) // "/aem" added to the front of the base URL we're testing + .build(); + } + + @ParameterizedTest + @ValueSource(strings = { + "/libs/granite/csrf/token.json", + "/lc/libs/granite/csrf/token.json", + "/etc.clientlibs/clientlibs/granite/jquery/granite/csrf.js", + "/etc.clientlibs/fd/xfaforms/clientlibs/I18N/en.js", + "/etc.clientlibs/fd/xfaforms/clientlibs/I18N/en_US.js", + "/etc.clientlibs/fd/xfaforms/clientlibs/profile.css", + }) + void testProxyUnmodifiedGet(String endpoint) { + // Given + String aemResponseText = "Value should be unmodified. " + MODIFICATION_TARGETS; + runTest(endpoint, aemResponseText, aemResponseText); + } + + final static List MODIFIED_GET_ARGUMENTS = List.of( + Arguments.of("/etc.clientlibs/clientlibs/granite/utils.js", "\"" + AF_BASE_LOCATION + "\" + ", ""), + Arguments.of("/etc.clientlibs/fd/xfaforms/clientlibs/profile.js", "", "/aem") + ); + + @ParameterizedTest + @FieldSource("MODIFIED_GET_ARGUMENTS") + void testProxyModifiedGet(String endpoint, String modValueUtilsJs, String modValueProfileJs) { + // Given + String aemResponseText = "Value should be modified. " + MODIFICATION_TARGETS; + String expectedResult = "Value should be modified. " + MODIFICATION_TARGETS_FORMAT_STR.formatted(requireNonNullElse(modValueUtilsJs, ""), requireNonNullElse(modValueProfileJs, "")); + runTest(endpoint, aemResponseText, expectedResult); + } + + @Test + void testProxyGet_Utils_Js() { + // Given + String endpoint = "/etc.clientlibs/clientlibs/granite/utils.js"; + String aemResponseText = "Value to be modified 'contextPath = result[1];'"; + String expectedResponseText = "Value to be modified 'contextPath = \"" + AF_BASE_LOCATION + "\" + result[1];'"; + runTest(endpoint, aemResponseText, expectedResponseText); + } + + private void runTest(String endpoint, String inputText, String expectedResponseText) { + stubFor(get(urlPathEqualTo(endpoint)).willReturn(okForContentType("text/plain", inputText))); + + logger.atInfo() + .addArgument(endpoint) + .addArgument(inputText) + .addArgument(expectedResponseText) + .log("Testing proxy endpoint '{}' with input '{}', expecting response '{}'."); + + // When + // Make rest call to the proxy endpoint + String result; + try { + result = restClient.get() + .uri(endpoint) + .retrieve() + .body(String.class); + } catch (Exception e) { + logger.atError() + .addArgument(endpoint) + .addArgument(inputText) + .addArgument(expectedResponseText) + .log("Caught exception while testing proxy endpoint '{}' with input '{}', expecting response '{}'."); + throw e; + } + + assertNotNull(result); + assertEquals(expectedResponseText, result); + } + + @ParameterizedTest + @ValueSource(strings = { + "/jcr:content/guideContainer.af.internalsubmit.jsp", + "/jcr:content/guideContainer.af.submit.jsp" + }) + void testProxyPost(String endpoint) { + String aemResponseText = "Value should be unmodified. " + MODIFICATION_TARGETS; + stubFor(post(urlPathEqualTo(endpoint)).willReturn(okForContentType("text/plain", aemResponseText))); + + // When + // Make rest call to the proxy endpoint + String result = restClient.post() + .uri(endpoint) + .retrieve() + .body(String.class); + + assertNotNull(result); + assertEquals(aemResponseText, result); + } + + @SpringBootApplication + @EnableConfigurationProperties({AemConfiguration.class, AemProxyConfiguration.class}) + public static class TestApplication { + public static void main(String[] args) { + SpringApplication.run(TestApplication.class, args); + } + +// @Bean +// public ResourceConfigCustomizer afProxyConfigurer(AemConfiguration aemConfig, AemProxyConfiguration aemProxyConfig, @Autowired(required = false) SslBundles sslBundles) { +// return config->config.register(new AemProxyEndpoint(aemConfig, aemProxyConfig, sslBundles)); +// } + } +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/FluentFormsJerseyAutoConfigurationTest.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/FluentFormsJerseyAutoConfigurationTest.java new file mode 100644 index 00000000..369a2f05 --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/FluentFormsJerseyAutoConfigurationTest.java @@ -0,0 +1,285 @@ +package com._4point.aem.fluentforms.spring; + +import static org.junit.jupiter.api.Assertions.*; + +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.function.Function; +import java.util.stream.Collectors; + +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.test.context.SpringBootTest; + +import com._4point.aem.docservices.rest_services.client.RestClient; +import com._4point.aem.docservices.rest_services.client.af.AdaptiveFormsService; +import com._4point.aem.docservices.rest_services.client.helpers.AemConfig; +import com._4point.aem.docservices.rest_services.client.helpers.Builder.RestClientFactory; +import com._4point.aem.docservices.rest_services.client.html5.Html5FormsService; +import com._4point.aem.docservices.rest_services.client.jersey.JerseyRestClient; +import com._4point.aem.fluentforms.api.DocumentFactory; +import com._4point.aem.fluentforms.api.assembler.AssemblerService; +import com._4point.aem.fluentforms.api.convertPdf.ConvertPdfService; +import com._4point.aem.fluentforms.api.docassurance.DocAssuranceService; +import com._4point.aem.fluentforms.api.forms.FormsService; +import com._4point.aem.fluentforms.api.generatePDF.GeneratePDFService; +import com._4point.aem.fluentforms.api.output.OutputService; +import com._4point.aem.fluentforms.api.pdfUtility.PdfUtilityService; +import com._4point.aem.fluentforms.spring.rest_services.client.SpringRestClientRestClient; + +@SpringBootTest(classes = {FluentFormsJerseyAutoConfigurationTest.TestApplication.class, FluentFormsJerseyAutoConfiguration.class, FluentFormsAutoConfiguration.class}, + properties = { + "fluentforms.aem.servername=localhost", + "fluentforms.aem.port=4502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin)", + }) +class FluentFormsJerseyAutoConfigurationTest { + + @Test + void testAdaptiveFormsService(@Autowired AdaptiveFormsService service) { + assertNotNull(service); + } + + @Test + void testAssemblerService(@Autowired AssemblerService service) { + assertNotNull(service); + } + + @Test + void testDocAssuranceService(@Autowired DocAssuranceService service) { + assertNotNull(service); + } + + @Test + void testFormsService(@Autowired FormsService service) { + assertNotNull(service); + } + + @Test + void testGeneratePDFService(@Autowired GeneratePDFService service) { + assertNotNull(service); + } + + @Test + void testHtml5FormsService(@Autowired Html5FormsService service) { + assertNotNull(service); + } + + @Test + void testOutputService(@Autowired OutputService service) { + assertNotNull(service); + } + + @Test + void testPdfUtilityService(@Autowired PdfUtilityService service) { + assertNotNull(service); + } + + @Test + void testConvertPdfService(@Autowired ConvertPdfService service) { + assertNotNull(service); + } + + @Test + void testDocumentFactory(@Autowired DocumentFactory factory) { + assertNotNull(factory); + assertNotNull(factory.create(new byte[6])); + } + + @Test + void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { + RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); + assertTrue(client instanceof JerseyRestClient, "RestClientFactory should return a JerseyRestClient by default"); + } + + @Test + void testAfInputStreamFilterFactory(@Autowired Function afInputStreamFilter) throws Exception { + final String INPUT_STRING = "/etc.clientlibs/foobar"; + final String EXPECTED_RESULT_STRING = "/aem/etc.clientlibs/foobar"; + + assertNotNull(afInputStreamFilter); + assertEquals(EXPECTED_RESULT_STRING, applyStreamFilter(INPUT_STRING, afInputStreamFilter)); + } + + @SpringBootApplication + @EnableConfigurationProperties({AemConfiguration.class}) + public static class TestApplication { + public static void main(String[] args) { + SpringApplication.run(TestApplication.class, args); + } + } + + @SpringBootTest(classes = {FluentFormsJerseyAutoConfigurationTest.TestApplication.class, FluentFormsJerseyAutoConfiguration.class, FluentFormsAutoConfiguration.class}, + properties = { + "fluentforms.aem.servername=localhost", + "fluentforms.aem.port=4502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin)", + "fluentforms.rproxy.aemPrefix=/app_prefix", + "fluentforms.rproxy.clientPrefix=/client_prefix", + }) + public static class AfStreamFilterTest { + + @Test + void testAfInputStreamFilterFactory(@Autowired Function afInputStreamFilter) throws Exception { + final String INPUT_STRING = "/app_prefix/etc.clientlibs/foobar"; + final String EXPECTED_RESULT_STRING = "/client_prefix/aem/app_prefix/etc.clientlibs/foobar"; + + assertNotNull(afInputStreamFilter); + assertEquals(EXPECTED_RESULT_STRING, applyStreamFilter(INPUT_STRING, afInputStreamFilter)); + } + } + + private static String applyStreamFilter(String inputString, Function afInputStreamFilter) { + try (InputStream is = afInputStreamFilter.apply(stringToInputStream(inputString))) { + return inputStreamToString(is); + } catch (IOException e) { + throw new IllegalStateException(e); + } + } + + private static InputStream stringToInputStream(String inputString) { + return new ByteArrayInputStream(inputString.getBytes(StandardCharsets.UTF_8)); + } + + private static String inputStreamToString(InputStream inputStream) throws IOException { + String result = new BufferedReader( + new InputStreamReader(inputStream, StandardCharsets.UTF_8)) + .lines() + .collect(Collectors.joining("\n")); + return result; + } + + @SpringBootTest(classes = {FluentFormsJerseyAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, + properties = { + "fluentforms.aem.servername=localhost", + "fluentforms.aem.port=4502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin", + "fluentforms.restclient=springrestclient" // Configure for Spring RestClient + }) + public static class SpringRestClientTest { + + @Test + void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { + RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); + assertTrue(client instanceof SpringRestClientRestClient, "RestClientFactory should return a SpringRestClientRestClient when configured to do so"); + } + } + + @SpringBootTest(classes = {FluentFormsJerseyAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, + properties = { + "fluentforms.aem.servername=localhost", + "fluentforms.aem.port=4502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin", + "fluentforms.aem.usessl=true", + "fluentforms.restclient=springrestclient" // Configure for Spring RestClient + }) + public static class SpringRestClient_SslNoBundleNameTest { + + @Test + void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { + RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); + assertTrue(client instanceof SpringRestClientRestClient, "RestClientFactory should return a SpringRestClientRestClient when configured to do so"); + } + } + + @SpringBootTest(classes = {FluentFormsJerseyAutoConfigurationTest.TestApplication.class, FluentFormsJerseyAutoConfiguration.class, FluentFormsAutoConfiguration.class}, + properties = { + "fluentforms.aem.servername=localhost", + "fluentforms.aem.port=4502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin", + "fluentforms.aem.usessl=true", + "fluentforms.rproxy.enabled=false", + "fluentforms.restclient=jersey" // Configure for Jersey RestClient + }) + public static class JserseyRestClient_SslNoBundleNameTest { + + @Test + void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { + RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); + assertTrue(client instanceof JerseyRestClient, "RestClientFactory should return a JerseyRestClient when configured to do so"); + } + } + + @SpringBootTest(classes = {FluentFormsJerseyAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, + properties = { + "fluentforms.aem.servername=localhost", + "fluentforms.aem.port=4502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin", + "fluentforms.aem.usessl=true", + "spring.ssl.bundle.jks.aem.truststore.location=file:src/test/resources/aemforms.p12", + "spring.ssl.bundle.jks.aem.truststore.password=Pa$$123", + "spring.ssl.bundle.jks.aem.truststore.type=PKCS12", + "fluentforms.restclient=springrestclient" // Configure for Spring RestClient + }) + public static class SpringRestClient_SslBundleTest { + + @Test + void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { + RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); + assertTrue(client instanceof SpringRestClientRestClient, "RestClientFactory should return a SpringRestClientRestClient when configured to do so"); + } + } + + @SpringBootTest(classes = {FluentFormsJerseyAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, + properties = { + "fluentforms.aem.servername=localhost", + "fluentforms.aem.port=4502", + "fluentforms.aem.user=admin", + "fluentforms.aem.password=admin", + "fluentforms.aem.usessl=true", + "spring.ssl.bundle.jks.aem.truststore.location=file:src/test/resources/aemforms.p12", + "spring.ssl.bundle.jks.aem.truststore.password=Pa$$123", + "spring.ssl.bundle.jks.aem.truststore.type=PKCS12", + "fluentforms.restclient=jersey" // Configure for Jersey RestClient + }) + public static class JserseyRestClient_SslBundleTest { + + @Test + void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { + RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); + assertTrue(client instanceof JerseyRestClient, "RestClientFactory should return a JerseyRestClient when configured to do so"); + } + } + private static AemConfig toAemConfig(AemConfiguration config) { + return new AemConfig() { + + @Override + public String servername() { + return config.servername(); + } + + @Override + public Integer port() { + return config.port(); + } + + @Override + public String user() { + return config.user(); + } + + @Override + public String password() { + return config.password(); + } + + @Override + public Boolean useSsl() { + return config.useSsl(); + } + }; + } +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyAutoConfigurationTest.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyAutoConfigurationTest.java new file mode 100644 index 00000000..5cf571aa --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyAutoConfigurationTest.java @@ -0,0 +1,252 @@ +package com._4point.aem.fluentforms.spring; + +import static org.assertj.core.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.springframework.boot.autoconfigure.AutoConfigurations; +import org.springframework.boot.autoconfigure.web.client.RestClientSsl; +import org.springframework.boot.test.context.assertj.AssertableApplicationContext; +import org.springframework.boot.test.context.assertj.AssertableWebApplicationContext; +import org.springframework.boot.test.context.runner.ApplicationContextRunner; +import org.springframework.boot.test.context.runner.ContextConsumer; +import org.springframework.boot.test.context.runner.WebApplicationContextRunner; +import org.springframework.context.annotation.Bean; +import org.springframework.web.client.RestClient; + +import com._4point.aem.fluentforms.api.output.OutputService; +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler; +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.SpringAfSubmitProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.AfSubmitAemProxyProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.AfSubmitLocalProcessor; +import com._4point.aem.fluentforms.spring.AemProxyJerseyAfSubmission.JerseyAfSubmitProcessor; + +/** + * Test that AutoConfiguration happens. The code in this test class is based on the following docs: + * + * https://spring.io/blog/2018/03/07/testing-auto-configurations-with-spring-boot-2-0 + * + */ +class JerseyAutoConfigurationTest { + + /** + * This class provides mock versions of beans that would normally be provided by Spring Boot in a real application. We + * only need to mock out the RestClient.Builder and RestClientSsl beans because those are the only Spring Boot provided + * beans that our AutoConfigurations depend on. + */ + private static class SpringBootMocks { + @Bean RestClient.Builder mockRestClientBuilder() { return Mockito.mock(RestClient.Builder.class, Mockito.RETURNS_DEEP_STUBS); } + @Bean private RestClientSsl mockRestClientSsl() { return Mockito.mock(RestClientSsl.class); } + } + + private static final AutoConfigurations AUTO_CONFIG = AutoConfigurations.of(FluentFormsJerseyAutoConfiguration.class, AemProxyJerseyAutoConfiguration.class, FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class, SpringBootMocks.class); + + private static final AutoConfigurations LOCAL_SUBMIT_CONFIG = AutoConfigurations.of(FluentFormsJerseyAutoConfiguration.class, AemProxyJerseyAutoConfiguration.class, FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class, DummyLocalSubmitHandler.class, SpringBootMocks.class); + + private static final AutoConfigurations ALTERNATE_PROXY_CONFIG = AutoConfigurations.of(DummyProxyImplementation.class, FluentFormsJerseyAutoConfiguration.class, AemProxyJerseyAutoConfiguration.class, FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class, SpringBootMocks.class); + + // Tests to make sure that only the FluentFormsLibraries are loaded in a non-web application. + private static final ContextConsumer FF_LIBRARIES_ONLY = (context) -> { + assertAll( + ()->assertThat(context).hasSingleBean(FluentFormsAutoConfiguration.class), + ()->assertThat(context).getBean(FluentFormsAutoConfiguration.class.getName()).isSameAs(context.getBean(FluentFormsAutoConfiguration.class)), + ()->assertThat(context).hasSingleBean(OutputService.class), + ()->assertThat(context).getBean("outputService").isNotNull(), + ()->assertThat(context).doesNotHaveBean(AemProxyAutoConfiguration.class), + ()->assertThat(context).doesNotHaveBean(SpringAfSubmitProcessor.class), + ()->assertThat(context).doesNotHaveBean(AfSubmissionHandler.class), + ()->assertThat(context).doesNotHaveBean(AemProxyJerseyAutoConfiguration.class), + ()->assertThat(context).doesNotHaveBean(JerseyAfSubmitProcessor.class) + ); + }; + + // Tests to make sure that only the FluentFormsLibraries are loaded in a web application. + private static final ContextConsumer WEB_FF_LIBRARIES_ONLY = (context) -> { + assertAll( + ()->assertThat(context).hasSingleBean(FluentFormsAutoConfiguration.class), + ()->assertThat(context).getBean(FluentFormsAutoConfiguration.class.getName()).isSameAs(context.getBean(FluentFormsAutoConfiguration.class)), + ()->assertThat(context).hasSingleBean(OutputService.class), + ()->assertThat(context).getBean("outputService").isNotNull(), + ()->assertThat(context).doesNotHaveBean(AemProxyAutoConfiguration.class), + ()->assertThat(context).doesNotHaveBean(SpringAfSubmitProcessor.class), + ()->assertThat(context).doesNotHaveBean(AfSubmissionHandler.class), + ()->assertThat(context).doesNotHaveBean(AemProxyJerseyAutoConfiguration.class), + ()->assertThat(context).doesNotHaveBean(JerseyAfSubmitProcessor.class) + ); + }; + + // Tests to make sure that all beans are loaded by default in a web application. + private static final ContextConsumer WEB_ALL_DEFAULT_SERVICES = (context) -> { + assertAll( + ()->assertThat(context).hasSingleBean(FluentFormsAutoConfiguration.class), + ()->assertThat(context).getBean(FluentFormsAutoConfiguration.class.getName()).isSameAs(context.getBean(FluentFormsAutoConfiguration.class)), + ()->assertThat(context).hasSingleBean(OutputService.class), + ()->assertThat(context).getBean("outputService").isNotNull(), + ()->assertThat(context).hasSingleBean(AemProxyJerseyAutoConfiguration.class), + ()->assertThat(context).getBean(AemProxyJerseyAutoConfiguration.class.getName()).isSameAs(context.getBean(AemProxyJerseyAutoConfiguration.class)), + ()->assertThat(context).hasSingleBean(JerseyAfSubmitProcessor.class), + ()->assertThat(context).getBean(JerseyAfSubmitProcessor.class).isSameAs(context.getBean(AfSubmitAemProxyProcessor.class)), + ()->assertThat(context).doesNotHaveBean(AfSubmissionHandler.class) + ); + }; + + // Tests to make sure that all beans are loaded by default in a web application. + private static final ContextConsumer WEB_ALL_SPRINGMVC_SERVICES = (context) -> { + assertAll( + ()->assertThat(context).hasSingleBean(FluentFormsAutoConfiguration.class), + ()->assertThat(context).getBean(FluentFormsAutoConfiguration.class.getName()).isSameAs(context.getBean(FluentFormsAutoConfiguration.class)), + ()->assertThat(context).hasSingleBean(OutputService.class), + ()->assertThat(context).getBean("outputService").isNotNull(), + ()->assertThat(context).hasSingleBean(AemProxyAutoConfiguration.class), + ()->assertThat(context).getBean(AemProxyAutoConfiguration.class.getName()).isSameAs(context.getBean(AemProxyAutoConfiguration.class)), + ()->assertThat(context).hasSingleBean(SpringAfSubmitProcessor.class), + ()->assertThat(context).getBean(SpringAfSubmitProcessor.class).isSameAs(context.getBean(AemProxyAfSubmission.AfSubmitAemProxyProcessor.class)), + ()->assertThat(context).doesNotHaveBean(AfSubmissionHandler.class), + ()->assertThat(context).doesNotHaveBean(AemProxyJerseyAutoConfiguration.class), + ()->assertThat(context).doesNotHaveBean(JerseyAfSubmitProcessor.class) + ); + }; + + // Tests to make sure that all beans are loaded in a web application that contains a local submit handler. + private static final ContextConsumer WEB_LOCAL_SUBMIT_SERVICES = (context) -> { + assertAll( + ()->assertThat(context).hasSingleBean(FluentFormsAutoConfiguration.class), + ()->assertThat(context).getBean(FluentFormsAutoConfiguration.class.getName()).isSameAs(context.getBean(FluentFormsAutoConfiguration.class)), + ()->assertThat(context).hasSingleBean(OutputService.class), + ()->assertThat(context).getBean("outputService").isNotNull(), + ()->assertThat(context).hasSingleBean(AemProxyJerseyAutoConfiguration.class), + ()->assertThat(context).getBean(AemProxyJerseyAutoConfiguration.class.getName()).isSameAs(context.getBean(AemProxyJerseyAutoConfiguration.class)), + ()->assertThat(context).hasSingleBean(JerseyAfSubmitProcessor.class), + ()->assertThat(context).getBean(JerseyAfSubmitProcessor.class).isSameAs(context.getBean(AfSubmitLocalProcessor.class)), + ()->assertThat(context).hasSingleBean(AfSubmissionHandler.class), + ()->assertThat(context).getBean(DummyLocalSubmitHandler.class).isSameAs(context.getBean(AfSubmissionHandler.class)) + ); + }; + + private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withConfiguration(AUTO_CONFIG); + + private final WebApplicationContextRunner webContextRunner = new WebApplicationContextRunner() + .withConfiguration(AUTO_CONFIG); + + private final WebApplicationContextRunner webLocalSubmitContextRunner = new WebApplicationContextRunner() + .withConfiguration(LOCAL_SUBMIT_CONFIG); + + private final WebApplicationContextRunner webAlternateProxyContextRunner = new WebApplicationContextRunner() + .withConfiguration(ALTERNATE_PROXY_CONFIG); + + // Only the services that do not require a web server should be started. + @Test + void nonWebContext_StartNonWebServices() { + this.contextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password") + .run(FF_LIBRARIES_ONLY); + } + + // All services should start when a proper web context has been initialized. + @Test + void webContext_StartAllServices() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password") + .run(WEB_ALL_DEFAULT_SERVICES); + } + + // Only the FluentForms libraries are instantiated when the proxy is explicitly disabled. + @Test + void webContext_ProxyDisabled_StartNonProxyServices() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password", + "fluentforms.rproxy.enabled=false") + .run(WEB_FF_LIBRARIES_ONLY); + } + + // Only the FluentForms libraries are instantiated when the proxy is not properly disabled. + @Test + void webContext_ProxyNotSpecifiedCorrectly_StartNonProxyServices() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password", + "fluentforms.rproxy.enabled=foobar") + .run(WEB_FF_LIBRARIES_ONLY); + } + + // All services should start when the proxy has been explicitly enabled. + @Test + void webContext_ProxyEnabled_StartNonProxyServices() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password", + "fluentforms.rproxy.enabled=true") + .run(WEB_ALL_DEFAULT_SERVICES); + } + + // All services should start when a proper web context has been initialized. + @Test + void webContext_StartAllServices_LocalSubmit() { + this.webLocalSubmitContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password") + .run(WEB_LOCAL_SUBMIT_SERVICES); + } + + // Only the FluentForms libraries are instantiated by this autoconfiguration when an alternate proxy implementation is supplied. + @Test + void webContext_StartAllServices_AlternateProxySupplied() { + this.webAlternateProxyContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password") + .run(WEB_FF_LIBRARIES_ONLY); + } + + // Only the FluentForms libraries are instantiated when an alternate proxy tyoe is configured. + @Test + void webContext_ProxyDisabled_AlternateProxyConfigured() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password", + "fluentforms.rproxy.type=someothertype") + .run(WEB_FF_LIBRARIES_ONLY); + } + + // All services should start when the jersey proxy type is configured. + @Test + void webContext_ProxyEnabled_DefaultProxyConfigured() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password", + "fluentforms.rproxy.type=jersey") + .run(WEB_ALL_DEFAULT_SERVICES); + } + + // All services should start when the jersey proxy type is configured. + @Test + void webContext_ProxyEnabled_SpringMvcProxyConfigured() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password", + "fluentforms.rproxy.type=springmvc") + .run(WEB_ALL_SPRINGMVC_SERVICES); + } + + + public static class DummyLocalSubmitHandler implements AfSubmissionHandler { + + @Override + public boolean canHandle(String formName) { + return false; + } + + @Override + public SubmitResponse processSubmission(Submission submission) { + return null; + } + } + + public static class DummyProxyImplementation implements AemProxyImplemention { + + } +} diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyClientFactoryTest.java b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyClientFactoryTest.java similarity index 99% rename from spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyClientFactoryTest.java rename to spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyClientFactoryTest.java index 80cf0470..4f2098cf 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyClientFactoryTest.java +++ b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/JerseyClientFactoryTest.java @@ -70,4 +70,4 @@ void testCreateClient_NullSslBundles_NullString() throws Exception { assertNotNull(client.getSslContext()); } -} +} \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/resources/aemforms.p12 b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/resources/aemforms.p12 new file mode 100644 index 00000000..2e835490 Binary files /dev/null and b/spring/fluentforms-jersey-spring-boot-autoconfigure/src/test/resources/aemforms.p12 differ diff --git a/spring/fluentforms-jersey-spring-boot-starter/pom.xml b/spring/fluentforms-jersey-spring-boot-starter/pom.xml new file mode 100644 index 00000000..f5efb9c4 --- /dev/null +++ b/spring/fluentforms-jersey-spring-boot-starter/pom.xml @@ -0,0 +1,78 @@ + + 4.0.0 + com._4point.aem.fluentforms + + org.springframework.boot + spring-boot-starter-parent + 3.5.7 + + + fluentforms-jersey-spring-boot-starter + 0.0.4-SNAPSHOT + FluentForms Jersey Spring Boot Starter + Spring Boot starter for FluentForms library using Jersey + + 17 + 3.0.5 + 3.0.5 + 0.0.4-SNAPSHOT + 0.0.4-SNAPSHOT + + + + + github + 4Point Solutions FluentFormsAPI Apache Maven Packages + https://maven.pkg.github.com/4PointSolutions/FluentFormsAPI + + + + + + github + https://maven.pkg.github.com/4PointSolutions/* + + true + + + + + + + + org.springframework.boot + spring-boot-starter + + + com._4point.aem.fluentforms + fluentforms-jersey-spring-boot-autoconfigure + ${fluentforms-jersey-autoconfigure.version} + + + + + + + + com.github.ulisesbocchio + jasypt-maven-plugin + ${jasypt.maven.plugin.version} + + + + \ No newline at end of file diff --git a/spring/fluentforms-jersey-spring-boot-starter/src/main/java/.gitignore b/spring/fluentforms-jersey-spring-boot-starter/src/main/java/.gitignore new file mode 100644 index 00000000..e69de29b diff --git a/spring/fluentforms-jersey-spring-boot-starter/src/main/resources/.gitignore b/spring/fluentforms-jersey-spring-boot-starter/src/main/resources/.gitignore new file mode 100644 index 00000000..e69de29b diff --git a/spring/fluentforms-jersey-spring-boot-starter/src/test/java/.gitignore b/spring/fluentforms-jersey-spring-boot-starter/src/test/java/.gitignore new file mode 100644 index 00000000..e69de29b diff --git a/spring/fluentforms-jersey-spring-boot-starter/src/test/resources/.gitignore b/spring/fluentforms-jersey-spring-boot-starter/src/test/resources/.gitignore new file mode 100644 index 00000000..e69de29b diff --git a/spring/fluentforms-sample-cli-app/pom.xml b/spring/fluentforms-sample-cli-app/pom.xml index dfd9a097..1b4c92ff 100644 --- a/spring/fluentforms-sample-cli-app/pom.xml +++ b/spring/fluentforms-sample-cli-app/pom.xml @@ -50,6 +50,20 @@ org.springframework.boot spring-boot-maven-plugin + + + maven-install-plugin + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + diff --git a/spring/fluentforms-sample-web-jersey-app/pom.xml b/spring/fluentforms-sample-web-jersey-app/pom.xml index 50c3f6b3..09ba17fa 100644 --- a/spring/fluentforms-sample-web-jersey-app/pom.xml +++ b/spring/fluentforms-sample-web-jersey-app/pom.xml @@ -6,6 +6,7 @@ org.springframework.boot spring-boot-starter-parent 3.5.7 + com._4point.aem.fluentforms fluentforms-sample-web-app @@ -18,7 +19,7 @@ 3.13.1 3.10.6 4.16.0 - 0.0.5-SNAPSHOT + 0.0.4-SNAPSHOT 0.0.4-SNAPSHOT @@ -67,8 +68,8 @@ com._4point.aem.fluentforms - fluentforms-spring-boot-starter - ${fluentforms.spring.boot.starter.version} + fluentforms-jersey-spring-boot-starter + ${fluentforms.jersey.spring.boot.starter.version} @@ -122,6 +123,20 @@ io.github.git-commit-id git-commit-id-maven-plugin + + + maven-install-plugin + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + diff --git a/spring/fluentforms-sample-webmvc-app/pom.xml b/spring/fluentforms-sample-webmvc-app/pom.xml index 04dd57de..4dc40985 100644 --- a/spring/fluentforms-sample-webmvc-app/pom.xml +++ b/spring/fluentforms-sample-webmvc-app/pom.xml @@ -6,6 +6,7 @@ org.springframework.boot spring-boot-starter-parent 3.5.7 + com._4point.aem.fluentforms fluentforms-sample-webmvc-app @@ -127,6 +128,20 @@ io.github.git-commit-id git-commit-id-maven-plugin + + + maven-install-plugin + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + diff --git a/spring/fluentforms-sample-webmvc-app/src/main/java/com/_4point/aem/fluentforms/sampleapp/JerseyConfig.java b/spring/fluentforms-sample-webmvc-app/src/main/java/com/_4point/aem/fluentforms/sampleapp/JerseyConfig.java deleted file mode 100644 index e788bd0f..00000000 --- a/spring/fluentforms-sample-webmvc-app/src/main/java/com/_4point/aem/fluentforms/sampleapp/JerseyConfig.java +++ /dev/null @@ -1,23 +0,0 @@ -package com._4point.aem.fluentforms.sampleapp; - -import java.util.Map; - -import org.glassfish.jersey.server.ResourceConfig; -import org.glassfish.jersey.servlet.ServletProperties; -import org.springframework.stereotype.Component; - -@Component -public class JerseyConfig extends ResourceConfig { - - public JerseyConfig() { - // Add properties that we want set - addProperties(Map.of( - // Turn off Wadl generation (this was interfering with some CORS functionality - "jersey.config.server.wadl.disableWadl", true, - "jersey.config.server.response.setStatusOverSendError", true, - // See https://docs.spring.io/spring-boot/how-to/jersey.html#howto .jersey.alongside-another-web-framework - ServletProperties.FILTER_FORWARD_ON_404, true - )); - } - -} \ No newline at end of file diff --git a/spring/fluentforms-sample-webmvc-app/src/test/java/com/_4point/aem/fluentforms/sampleapp/resources/WireMockAemProxyEndpointTest.java b/spring/fluentforms-sample-webmvc-app/src/test/java/com/_4point/aem/fluentforms/sampleapp/resources/WireMockAemProxyEndpointTest.java index 3f3b514b..9025e2f2 100644 --- a/spring/fluentforms-sample-webmvc-app/src/test/java/com/_4point/aem/fluentforms/sampleapp/resources/WireMockAemProxyEndpointTest.java +++ b/spring/fluentforms-sample-webmvc-app/src/test/java/com/_4point/aem/fluentforms/sampleapp/resources/WireMockAemProxyEndpointTest.java @@ -3,16 +3,11 @@ import static com.github.tomakehurst.wiremock.client.WireMock.*; import static org.junit.jupiter.api.Assertions.*; -import java.nio.file.Path; import java.util.List; import java.util.concurrent.TimeUnit; -import org.htmlunit.DefaultCredentialsProvider; -import org.htmlunit.WebClient; -import org.htmlunit.html.HtmlPage; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; import org.junit.jupiter.api.condition.EnabledIf; @@ -44,11 +39,10 @@ class WireMockAemProxyEndpointTest extends AbstractAemProxyEndpointTest { private static final boolean WIREMOCK_RECORDING = false; - private static final Path RESOURCES_DIR = Path.of("src", "test", "resources"); - private static final Path SAMPLE_FILES_DIR = RESOURCES_DIR.resolve("SampleFiles"); + private static final String CRX_CONTENT_ROOT = "crx:/content/dam/formsanddocuments/sample-forms/"; public WireMockAemProxyEndpointTest() { - super(SAMPLE_FILES_DIR.resolve(SAMPLE_XDP_FILENAME_PATH).toAbsolutePath().toString()); + super(CRX_CONTENT_ROOT + SAMPLE_XDP_FILENAME_PATH); } @BeforeEach @@ -86,46 +80,4 @@ protected void verifyProxyTest() { ) .forEach(url->verify(getRequestedFor(urlPathEqualTo(url)))); } - - - // In order to re-record the AEM interactions for Wiremock emulation, you need to: - // 1) run a local AEM server - // 2) set the WIREMOCK_RECORDING variable to true - // 3) then run this test. - // - // It will record the interactions with the AEM server. - // Don't forget to set the WIREMOCK_RECORDING variable back to false after you are done. - // - // Note: THe recordings may require modification. As of AEM 6.5 LTS, the required changes are: - // * Two calls to /content/xfaforms/profiles/default.html - One returns a 401, the other returns the form. - // This is because this HTMLUnit emulates a browser. The 401 recording can be deleted since the FluentForms code - // sends a pre-emptive authentication header. - // * the /etc.clientlibs/fd/xfaforms/clientlibs/I18N/en_US recording must be modified to make the _US optional. - // It appears that the FluentForms call does not include the _US suffix. - @Disabled("This test is not really a test but it is used to record interactions with the AEM server.") - @Test - void aemTest(WireMockRuntimeInfo wmRuntimeInfo) throws Exception { - DefaultCredentialsProvider userCredentials = new DefaultCredentialsProvider(); - userCredentials.addCredentials("admin", "admin".toCharArray()); - try (final WebClient webClient = new WebClient()) { - webClient.setCredentialsProvider(userCredentials); - String baseUri = "http://localhost:" + wmRuntimeInfo.getHttpPort() + "/content/xfaforms/profiles/default.html?contentRoot=crx:///content/dam/formsanddocuments/sample-forms&template=SampleForm.xdp"; - final HtmlPage page = webClient.getPage(baseUri); - assertEquals("LC Forms", page.getTitleText()); - -// final String pageAsXml = page.asXml(); -// assertTrue(pageAsXml.contains(""), "Does not contain topBarDisabled"); -// -// final String pageAsText = page.asNormalizedText(); -// assertTrue(pageAsText.contains("Support for the HTTP and HTTPS protocols")); - } - List.of("/content/xfaforms/profiles/default.html", - "/etc.clientlibs/toggles.json", - "/libs/granite/csrf/token.json", - "/etc.clientlibs/fd/xfaforms/clientlibs/I18N/en_US.js", - "/etc.clientlibs/fd/xfaforms/clientlibs/profile.css", - "/etc.clientlibs/fd/xfaforms/clientlibs/profile.js" - ) - .forEach(url->verify(getRequestedFor(urlPathEqualTo(url)))); - } } diff --git a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_content_xfaforms_profiles_default_html.json b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_content_xfaforms_profiles_default_html.json deleted file mode 100644 index 25e537b6..00000000 --- a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_content_xfaforms_profiles_default_html.json +++ /dev/null @@ -1,36 +0,0 @@ -{ - "id" : "42c7fedf-c9a2-44a8-acbb-9f0cc1260a39", - "name" : "content_xfaforms_profiles_default.html", - "request" : { - "urlPath" : "/content/xfaforms/profiles/default.html", - "method" : "GET", - "queryParameters" : { - "contentRoot" : { - "hasExactly" : [ { - "equalTo" : "crx:///content/dam/formsanddocuments/sample-forms" - } ] - }, - "template" : { - "hasExactly" : [ { - "equalTo" : "SampleForm.xdp" - } ] - } - } - }, - "response" : { - "status" : 200, - "body" : "\n\n\n\n \n \n\n\n\n\n\n\nLC Forms\n\n\n\n\n\n\n\n\n \n \n
\n
Loading
\n
\n \n \n\n\n\n\n
\n Please fill the following form.\n \n \n\n \n \n
\n\n \n\n\n\n\n\n\n\n\n \n \n \n\n\n\n\n \n\n\n\n \n \n\n\n\n\n\n
\n
\n

Loading...

\n \n
\n
\n\n\n\n\n \n \n\n
\n
\n
\n \n Loading...\n --Load now--\n
\n
\n --No more pages--\n
\n
\n
\n\n\n\n\n \n\n\n \n \n\n\n\n\n\n\n
\n
\n
\n
\n

Attachments

\n
\n
\n
\n\n
\n
\n \n
\n
\n \n
\n
\n
\n \n
\n \n
\n\n\n\n\n \n\n", - "headers" : { - "X-Content-Type-Options" : "nosniff", - "Set-Cookie" : "cq-authoring-mode=TOUCH; Path=/; Expires=Sun, 18-May-2025 11:23:43 GMT; Max-Age=604800", - "Expires" : "Thu, 01 Jan 1970 00:00:00 GMT", - "Date" : "Sun, 11 May 2025 11:23:43 GMT", - "Content-Type" : "text/html;charset=utf-8" - } - }, - "uuid" : "42c7fedf-c9a2-44a8-acbb-9f0cc1260a39", - "persistent" : true, - "scenarioName" : "scenario-1-content-xfaforms-profiles-default.html", - "requiredScenarioState" : "scenario-1-content-xfaforms-profiles-default.html-2", - "insertionIndex" : 23 -} \ No newline at end of file diff --git a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_clientlibs_granite_jquery_granite_csrf_js.json b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_clientlibs_granite_jquery_granite_csrf_js.json index e55231a8..b1a21afb 100644 --- a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_clientlibs_granite_jquery_granite_csrf_js.json +++ b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_clientlibs_granite_jquery_granite_csrf_js.json @@ -1,21 +1,22 @@ { - "id" : "00a42460-ec46-4cee-94e6-33ea44869f87", - "name" : "etc.clientlibs_clientlibs_granite_jquery_granite_csrf.js", + "id" : "7a26c766-1d0f-4af8-a2a5-f1d5cd028f5d", + "name" : "libs_granite_csrf_token.json", "request" : { - "url" : "/etc.clientlibs/clientlibs/granite/jquery/granite/csrf.js", + "url" : "/libs/granite/csrf/token.json", "method" : "GET" }, "response" : { "status" : 200, - "base64Body" : "/*
 * ADOBE CONFIDENTIAL
 *
 * Copyright 2015 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 *
 */
/* global CQURLInfo:false */
(function(window) {
    "use strict";

    window.Granite = window.Granite || {};
    window.Granite.HTTP = window.Granite.HTTP || {};

    var contextPath = null;

    function detectContextPath() {
        // eslint-disable-next-line max-len
        var SCRIPT_URL_REGEXP = /^(?:http|https):\/\/[^/]+(\/.*)\/(?:etc\.clientlibs|etc(\/.*)*\/clientlibs|libs(\/.*)*\/clientlibs|apps(\/.*)*\/clientlibs|etc\/designs).*\.js(\?.*)?$/;
        try {
            if (window.CQURLInfo) {
                contextPath = CQURLInfo.contextPath || "";
            } else {
                var scripts = document.getElementsByTagName("script");
                for (var i = 0; i < scripts.length; i++) {
                    var result = SCRIPT_URL_REGEXP.exec(scripts[i].src);
                    if (result) {
                        contextPath = result[1];
                        return;
                    }
                }
                contextPath = "";
            }
        } catch (e) {
            // ignored
        }
    }

    window.Granite.HTTP.externalize = window.Granite.HTTP.externalize || function(url) {
        if (contextPath === null) {
            detectContextPath();
        }

        try {
            if (url.indexOf("/") === 0 && contextPath && url.indexOf(contextPath + "/") !== 0) {
                url = contextPath + url;
            }
        } catch (e) {
            // ignored
        }

        return url;
    };
})(this);

/*
 * ADOBE CONFIDENTIAL
 *
 * Copyright 2015 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 *
 */
(function(factory) {
    "use strict";

    // GRANITE-22281 Check for multiple initialization
    if (window.Granite.csrf) {
        return;
    }

    window.Granite.csrf = factory(window.Granite.HTTP);
}(function(http) {
    "use strict";

    // AdobePatentID="P5296"

    function Promise() {
        this._handler = [];
    }

    Promise.prototype = {
        then: function(resolveFn, rejectFn) {
            this._handler.push({ resolve: resolveFn, reject: rejectFn });
        },
        resolve: function() {
            this._execute("resolve", arguments);
        },
        reject: function() {
            this._execute("reject", arguments);
        },
        _execute: function(result, args) {
            if (this._handler === null) {
                throw new Error("Promise already completed.");
            }

            for (var i = 0, ln = this._handler.length; i < ln; i++) {
                this._handler[i][result].apply(window, args);
            }

            this.then = function(resolveFn, rejectFn) {
                (result === "resolve" ? resolveFn : rejectFn).apply(window, args);
            };

            this._handler = null;
        }
    };

    function verifySameOrigin(url) {
        // url could be relative or scheme relative or absolute
        // host + port
        var host = document.location.host;
        var protocol = document.location.protocol;
        var relativeOrigin = "//" + host;
        var origin = protocol + relativeOrigin;

        // Allow absolute or scheme relative URLs to same origin
        return (url === origin || url.slice(0, origin.length + 1) === origin + "/") ||
                (url === relativeOrigin || url.slice(0, relativeOrigin.length + 1) === relativeOrigin + "/") ||
                // or any other URL that isn't scheme relative or absolute i.e relative.
                !(/^(\/\/|http:|https:).*/.test(url));
    }

    var FIELD_NAME = ":cq_csrf_token";
    var HEADER_NAME = "CSRF-Token";
    var TOKEN_SERVLET = http.externalize("/libs/granite/csrf/token.json");

    var promise;
    var globalToken;

    function logFailRequest(error) {
        if (window.console) {
            // eslint-disable-next-line no-console
            console.warn("CSRF data not available;" +
                    "The data may be unavailable by design, such as during non-authenticated requests: " + error);
        }
    }

    function getToken() {
        var localPromise = new Promise();
        promise = localPromise;

        var xhr = new XMLHttpRequest();
        xhr.onreadystatechange = function() {
            if (xhr.readyState === 4) {
                try {
                    var data = JSON.parse(xhr.responseText);
                    globalToken = data.token;
                    localPromise.resolve(globalToken);
                } catch (ex) {
                    logFailRequest(ex);
                    localPromise.reject(xhr.responseText);
                }
            }
        };
        xhr.open("GET", TOKEN_SERVLET, true);
        xhr.send();

        return localPromise;
    }

    function getTokenSync() {
        var xhr = new XMLHttpRequest();
        xhr.open("GET", TOKEN_SERVLET, false);
        xhr.send();

        try {
            return globalToken = JSON.parse(xhr.responseText).token;
        } catch (ex) {
            logFailRequest(ex);
        }
    }

    function clearToken() {
        globalToken = undefined;
        getToken();
    }

    function addField(form) {
        var action = form.getAttribute("action");
        if (form.method.toUpperCase() === "GET" || (action && !verifySameOrigin(action))) {
            return;
        }

        if (!globalToken) {
            getTokenSync();
        }

        if (!globalToken) {
            return;
        }

        var input = form.querySelector('input[name="' + FIELD_NAME + '"]');

        if (!input) {
            input = document.createElement("input");
            input.setAttribute("type", "hidden");
            input.setAttribute("name", FIELD_NAME);
            form.appendChild(input);
        }

        input.setAttribute("value", globalToken);
    }

    function handleForm(document) {
        var handler = function(ev) {
            var t = ev.target;

            if (t.nodeName === "FORM") {
                addField(t);
            }
        };

        if (document.addEventListener) {
            document.addEventListener("submit", handler, true);
        } else if (document.attachEvent) {
            document.attachEvent("submit", handler);
        }
    }

    handleForm(document);

    var open = XMLHttpRequest.prototype.open;

    XMLHttpRequest.prototype.open = function(method, url, async) {
        if (method.toLowerCase() !== "get" && verifySameOrigin(url)) {
            this._csrf = true;
            this._async = async;
        }

        return open.apply(this, arguments);
    };

    var send = XMLHttpRequest.prototype.send;

    XMLHttpRequest.prototype.send = function() {
        if (!this._csrf) {
            send.apply(this, arguments);
            return;
        }

        if (globalToken) {
            this.setRequestHeader(HEADER_NAME, globalToken);
            send.apply(this, arguments);
            return;
        }

        if (this._async === false) {
            getTokenSync();

            if (globalToken) {
                this.setRequestHeader(HEADER_NAME, globalToken);
            }

            send.apply(this, arguments);
            return;
        }

        var self = this;
        var args = Array.prototype.slice.call(arguments);

        promise.then(function(token) {
            self.setRequestHeader(HEADER_NAME, token);
            send.apply(self, args);
        }, function() {
            send.apply(self, args);
        });
    };

    var submit = HTMLFormElement.prototype.submit;

    HTMLFormElement.prototype.submit = function() {
        addField(this);
        return submit.apply(this, arguments);
    };

    if (window.Node) {
        var ac = Node.prototype.appendChild;

        Node.prototype.appendChild = function() {
            var result = ac.apply(this, arguments);

            if (result.nodeName === "IFRAME") {
                try {
                    if (result.contentWindow && !result._csrf) {
                        result._csrf = true;
                        handleForm(result.contentWindow.document);
                    }
                } catch (ex) {
                    if (result.src && result.src.length && verifySameOrigin(result.src)) {
                        if (window.console) {
                            // eslint-disable-next-line no-console
                            console.error("Unable to attach CSRF token to an iframe element on the same origin");
                        }
                    }

                    // Potential error: Access is Denied
                    // we can safely ignore CORS security errors here
                    // because we do not want to expose the csrf anyways to another domain
                }
            }

            return result;
        };
    }

    // refreshing csrf token periodically
    getToken();

    setInterval(function() {
        getToken();
    }, 300000);

    return {
        initialised: false,
        refreshToken: getToken,
        _clearToken: clearToken
    };
}));

", + "body" : "{\"token\":\"eyJleHAiOjE3NjMzMDM3OTQsImlhdCI6MTc2MzMwMzE5NH0.5v2R_70ZbNN7EUoVwrGql7hk1EBeJ2FepXfNUxQJkg8\"}", "headers" : { + "Cache-Control" : "no-cache", "X-Content-Type-Options" : "nosniff", - "Last-Modified" : "Sat, 03 May 2025 13:47:20 GMT", - "Date" : "Sun, 11 May 2025 11:23:44 GMT", - "Content-Type" : "application/javascript;charset=utf-8" + "Expires" : "-1", + "Date" : "Sun, 16 Nov 2025 14:26:34 GMT", + "Content-Type" : "application/json" } }, - "uuid" : "00a42460-ec46-4cee-94e6-33ea44869f87", + "uuid" : "7a26c766-1d0f-4af8-a2a5-f1d5cd028f5d", "persistent" : true, - "insertionIndex" : 20 + "insertionIndex" : 31 } \ No newline at end of file diff --git a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_i18n_en_us_js.json b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_i18n_en_us_js.json index 7751f30c..ccdbf588 100644 --- a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_i18n_en_us_js.json +++ b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_i18n_en_us_js.json @@ -1,8 +1,8 @@ { - "id" : "a1cf3903-7f2b-43f4-bbfe-862e68daaf6e", - "name" : "etc.clientlibs_fd_xfaforms_clientlibs_i18n_en_us.js", + "id" : "8bab67f2-6d86-4b88-85f3-660ae4be80bc", + "name" : "etc.clientlibs_fd_xfaforms_clientlibs_i18n_en.js", "request" : { - "urlPattern" : "/etc\\.clientlibs/fd/xfaforms/clientlibs/I18N/en(_US)?\\.js", + "url" : "/etc.clientlibs/fd/xfaforms/clientlibs/I18N/en.js", "method" : "GET" }, "response" : { @@ -10,12 +10,12 @@ "base64Body" : "/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/



;(function() {
    xfalib = {
        ut : {},
        script : {
            mixin : {},
            dom : {}
        },
        view : {
            util:{},
            layout:{}
        },
        runtime: {
            _private: {}
        },
        locale : {},
        acrobat: {}, //added for acrobat specific scripts
        template: {},
        globals: {
            highlight : false // flag for "Highlight Existing Fields"
        }
    };
    window.xfalib = xfalib;
})();

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function(xfalib){
xfalib.locale.Strings =
{
    "pleaseTapText"         :       "Please tap here to sign",
	"pleaseClickText"       :       "Please click here to sign",
	"clearSignature"        :       "Clear Signature Confirmation",
	"clearSignatureConfirm" :       "Are you sure you want to clear signature?",
	"fetchGeoLocation"      :       "Fetching Geo Location info...",
	"errorFetchGeoLocation" :       "Error fetching geolocation info",
	"pleaseSignText"        :       "Please sign here",
	"latitude"              :       "Latitude",
	"longitude"             :       "Longitude",
	"time"                  :       "Time",
    "clearText"             :       "Clear",
    "validationIssue"       :       "Validation Error in the field",
    "warning"               :       "Warnings",
    "errors"                :       "Errors",
    "errorServerScript"     :       "Error in running server script",
    "unableToConnectText"   :       "Couldn't connect to the server",
    "errorSubmittingForm"   :       "Error submitting form to internal url",
    "ok"                    :       "OK",
    "cancel"                :       "Cancel",
    "yes"                   :       "Yes",
    "no"                    :       "No",
    "clear"                 :       "Clear",
    "brushes"               :       "Brushes",
    "geolocation"           :       "Geolocation",
    "FileCloseAccessText"   :       "Press Enter to delete the file ",
    "FileSizeGreater"       :       "File(s) {0} are greater than the expected size: {1}MB.",
    "FileNameInvalid"       :       "Do not attach files where filename starts with (.), contains \\ / : * ? \" < > | ; % $, or is a reserved keyword like nul, prn, con, lpt, or com.",
    "FileMimeTypeInvalid"   :       "File(s) {0} are unsupported file types",
    "UnableToSave"          :       "Unable to save",
    "SavedSuccessfully"     :       "Saved Successfully",
    "Attach"                :       "Attach",
    "datePickerAriaLabel"   :       "Please Enter date in {0} format only",
    "typeYourSignatureHere" :       "Type Your Signature Here",
    "typeYourName"          :       "Type Your Name"
}
})(xfalib);

/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/




(function(xfalib){
xfalib.locale.LogMessages =
{
    "ALC-FRM-901-001"   :   "[ALC-FRM-901-001] : "+xfalib.locale.Strings.errorServerScript,
    "ALC-FRM-901-002"   :   "[ALC-FRM-901-002] : Exception occurred while executing {0} script for {1} : {2}.",
    "ALC-FRM-901-003"   :   "[ALC-FRM-901-003] : Error: xfa is not initialized.",
    "ALC-FRM-901-004"   :   "[ALC-FRM-901-004] : NullPointer Exception: {0} child {1} is null.",
    "ALC-FRM-901-005"   :   "[ALC-FRM-901-005] : exception {0} in parsing user script. script:{1}.",
    "ALC-FRM-901-006"   :   "[ALC-FRM-901-006] : Unsupported operation : {0}.",
    "ALC-FRM-901-007"   :   "[ALC-FRM-901-007] : Error in running server scripts. Type mismatch old: {0}, new: {1}.",
    "ALC-FRM-901-008"   :   "[ALC-FRM-901-008] : "+xfalib.locale.Strings.unableToConnectText,
    "ALC-FRM-901-009"   :   "[ALC-FRM-901-009] : Message Box with Yes/No are not supported and converted to Ok/Cancel message box but the return values are correct i.e for Yes/No",
    "ALC-FRM-901-010"   :   "[ALC-FRM-901-010] : Message Box with 3 buttons are not supported",
    "ALC-FRM-901-011"   :   "[ALC-FRM-901-011] : Geo Location not supported",
    "ALC-FRM-901-012"   :   "[ALC-FRM-901-012] : Mixed mode data binding is not supported",
    "ALC-FRM-901-013"   :   "[ALC-FRM-901-013] : Calculations failed after {0}",
    "ALC-FRM-901-014"   :   "[ALC-FRM-901-014] : Validation failed for the object: {0}. Validate Script is {1}",
    "ALC-FRM-901-015"   :   "[ALC-FRM-901-015] : exception {0} in creating user script object. user script:{1}, initialized from event: {2}, object : {3}",
    "ALC-FRM-901-016"   :   "[ALC-FRM-901-016] : "+xfalib.locale.Strings.errorSubmittingForm,
    "ALC-FRM-901-017"   :   "[ALC-FRM-901-017] : Exception occurred {0} while accessing property {1} of {2}" ,
    "ALC-FRM-901-018"   :   "[ALC-FRM-901-018] : This form may not render correctly as you are using an unsupported browser.",
    "ALC-FRM-901-019"   :   "[ALC-FRM-901-019] : Exception occurred while resolving floating fields for : {0}.",
    "ALC-FRM-901-020"   :   "[ALC-FRM-901-020] : Exception while Initializing Logger. Invalid Configuration {0} in {1}",
    "ALC-FRM-901-021"   :   "[ALC-FRM-901-021] : Failed to parse dataPattern {0} for the value {1}: {2}",
    "ALC-FRM-901-022"   :   "[ALC-FRM-901-022] : Skipped parsing Multiple dataPatterns  pattern {0} value {1}",
    "ALC-FRM-901-023"   :   "[ALC-FRM-901-023] : Numeric Patterns having the format (pattern) are not supported. " +
                                                    "Skipping pattern {0} value {1}"
}
})(xfalib);

", "headers" : { "X-Content-Type-Options" : "nosniff", - "Last-Modified" : "Sat, 03 May 2025 13:49:07 GMT", - "Date" : "Sun, 11 May 2025 11:23:44 GMT", + "Last-Modified" : "Thu, 18 Sep 2025 12:47:59 GMT", + "Date" : "Sun, 16 Nov 2025 14:26:31 GMT", "Content-Type" : "application/javascript;charset=utf-8" } }, - "uuid" : "a1cf3903-7f2b-43f4-bbfe-862e68daaf6e", + "uuid" : "8bab67f2-6d86-4b88-85f3-660ae4be80bc", "persistent" : true, - "insertionIndex" : 21 + "insertionIndex" : 35 } \ No newline at end of file diff --git a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_profile_css.json b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_profile_css.json index 3b0ef386..538e288e 100644 --- a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_profile_css.json +++ b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_profile_css.json @@ -1,5 +1,5 @@ { - "id" : "3e90f2cb-315a-4083-a77d-c94479894815", + "id" : "1a4d3741-e8fd-426c-ad01-e05ab57658fd", "name" : "etc.clientlibs_fd_xfaforms_clientlibs_profile.css", "request" : { "url" : "/etc.clientlibs/fd/xfaforms/clientlibs/profile.css", @@ -10,12 +10,14 @@ "body" : "/*!\n * Portions copyright © 2017 Adobe Systems Incorporated\n * Font Awesome 4.6.3 by @davegandy - http://fontawesome.io - @fontawesome\n * Font Awesome by Dave Gandy - http://fontawesome.io\n * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)\n */\n\n@font-face {\n font-family: 'fontello';\n src: url('../../rte/gui/components/clientlibs/thirdparty/resources/fontello.eot?66049208');\n src: url('../../rte/gui/components/clientlibs/thirdparty/resources/fontello.eot?66049208#iefix') format('embedded-opentype'),\n url('../../rte/gui/components/clientlibs/thirdparty/resources/fontello.woff2?66049208') format('woff2'),\n url('../../rte/gui/components/clientlibs/thirdparty/resources/fontello.woff?66049208') format('woff'),\n url('../../rte/gui/components/clientlibs/thirdparty/resources/fontello.ttf?66049208') format('truetype'),\n url('../../rte/gui/components/clientlibs/thirdparty/resources/fontello.svg?66049208#fontello') format('svg');\n font-weight: normal;\n font-style: normal;\n}\n/* Chrome hack: SVG is rendered more smooth in Windozze. 100% magic, uncomment if you need it. */\n/* Note, that will break hinting! In other OS-es font will be not as sharp as it could be */\n/*\n@media screen and (-webkit-min-device-pixel-ratio:0) {\n @font-face {\n font-family: 'fontello';\n src: url('../../rte/gui/components/clientlibs/thirdparty/font/fontello.svg?66049208#fontello') format('svg');\n }\n}\n*/\n \n [class^=\"icon-\"]:before, [class*=\" icon-\"]:before {\n font-family: \"fontello\";\n font-style: normal;\n font-weight: normal;\n speak: none;\n \n display: inline-block;\n text-decoration: inherit;\n width: 1em;\n margin-right: .2em;\n text-align: center;\n /* opacity: .8; */\n \n /* For safety - reset parent styles, that can break glyph codes*/\n font-variant: normal;\n text-transform: none;\n \n /* fix buttons height, for twitter bootstrap */\n line-height: 1em;\n \n /* Animation center compensation - margins should be symmetric */\n /* remove if not needed */\n margin-left: .2em;\n \n /* you can be more comfortable with increased icons size */\n /* font-size: 120%; */\n \n /* Font smoothing. That was taken from TWBS */\n -webkit-font-smoothing: antialiased;\n -moz-osx-font-smoothing: grayscale;\n \n /* Uncomment for 3D effect */\n /* text-shadow: 1px 1px 1px rgba(127, 127, 127, 0.3); */\n}\n \n.icon-search:before { content: '\\e800'; } /* '' */\n.icon-heart-empty:before { content: '\\e801'; } /* '' */\n.icon-star:before { content: '\\e802'; } /* '' */\n.icon-star-empty:before { content: '\\e803'; } /* '' */\n.icon-glass:before { content: '\\e804'; } /* '' */\n.icon-star-half:before { content: '\\e805'; } /* '' */\n.icon-user:before { content: '\\e806'; } /* '' */\n.icon-users:before { content: '\\e807'; } /* '' */\n.icon-video:before { content: '\\e808'; } /* '' */\n.icon-videocam:before { content: '\\e809'; } /* '' */\n.icon-picture:before { content: '\\e80a'; } /* '' */\n.icon-th:before { content: '\\e80b'; } /* '' */\n.icon-th-list:before { content: '\\e80c'; } /* '' */\n.icon-ok:before { content: '\\e80d'; } /* '' */\n.icon-ok-circled:before { content: '\\e80e'; } /* '' */\n.icon-ok-circled2:before { content: '\\e80f'; } /* '' */\n.icon-cancel:before { content: '\\e810'; } /* '' */\n.icon-cancel-circled:before { content: '\\e811'; } /* '' */\n.icon-cancel-circled2:before { content: '\\e812'; } /* '' */\n.icon-plus:before { content: '\\e813'; } /* '' */\n.icon-plus-circled:before { content: '\\e814'; } /* '' */\n.icon-help-circled:before { content: '\\e815'; } /* '' */\n.icon-info-circled:before { content: '\\e816'; } /* '' */\n.icon-link:before { content: '\\e817'; } /* '' */\n.icon-mail:before { content: '\\e818'; } /* '' */\n.icon-camera:before { content: '\\e819'; } /* '' */\n.icon-camera-alt:before { content: '\\e81a'; } /* '' */\n.icon-th-large:before { content: '\\e81b'; } /* '' */\n.icon-minus:before { content: '\\e81c'; } /* '' */\n.icon-minus-circled:before { content: '\\e81d'; } /* '' */\n.icon-attach:before { content: '\\e81e'; } /* '' */\n.icon-lock:before { content: '\\e81f'; } /* '' */\n.icon-lock-open:before { content: '\\e820'; } /* '' */\n.icon-pin:before { content: '\\e821'; } /* '' */\n.icon-eye:before { content: '\\e822'; } /* '' */\n.icon-eye-off:before { content: '\\e823'; } /* '' */\n.icon-tag:before { content: '\\e824'; } /* '' */\n.icon-tags:before { content: '\\e825'; } /* '' */\n.icon-bookmark:before { content: '\\e826'; } /* '' */\n.icon-flag:before { content: '\\e827'; } /* '' */\n.icon-thumbs-up:before { content: '\\e828'; } /* '' */\n.icon-download:before { content: '\\e829'; } /* '' */\n.icon-upload:before { content: '\\e82a'; } /* '' */\n.icon-forward:before { content: '\\e82b'; } /* '' */\n.icon-export:before { content: '\\e82c'; } /* '' */\n.icon-pencil:before { content: '\\e82d'; } /* '' */\n.icon-edit:before { content: '\\e82e'; } /* '' */\n.icon-print:before { content: '\\e82f'; } /* '' */\n.icon-retweet:before { content: '\\e830'; } /* '' */\n.icon-comment:before { content: '\\e831'; } /* '' */\n.icon-chat:before { content: '\\e832'; } /* '' */\n.icon-bell:before { content: '\\e833'; } /* '' */\n.icon-attention:before { content: '\\e834'; } /* '' */\n.icon-attention-circled:before { content: '\\e835'; } /* '' */\n.icon-location:before { content: '\\e836'; } /* '' */\n.icon-trash-empty:before { content: '\\e837'; } /* '' */\n.icon-doc:before { content: '\\e838'; } /* '' */\n.icon-phone:before { content: '\\e839'; } /* '' */\n.icon-cog:before { content: '\\e83a'; } /* '' */\n.icon-cog-alt:before { content: '\\e83b'; } /* '' */\n.icon-music:before { content: '\\e83c'; } /* '' */\n.icon-heart:before { content: '\\e83d'; } /* '' */\n.icon-home:before { content: '\\e83e'; } /* '' */\n.icon-thumbs-down:before { content: '\\e83f'; } /* '' */\n.icon-wrench:before { content: '\\e840'; } /* '' */\n.icon-basket:before { content: '\\e841'; } /* '' */\n.icon-calendar:before { content: '\\e842'; } /* '' */\n.icon-volume-off:before { content: '\\e843'; } /* '' */\n.icon-volume-down:before { content: '\\e844'; } /* '' */\n.icon-volume-up:before { content: '\\e845'; } /* '' */\n.icon-headphones:before { content: '\\e846'; } /* '' */\n.icon-clock:before { content: '\\e847'; } /* '' */\n.icon-block:before { content: '\\e848'; } /* '' */\n.icon-resize-vertical:before { content: '\\e849'; } /* '' */\n.icon-resize-horizontal:before { content: '\\e84a'; } /* '' */\n.icon-zoom-in:before { content: '\\e84b'; } /* '' */\n.icon-zoom-out:before { content: '\\e84c'; } /* '' */\n.icon-down-circled2:before { content: '\\e84d'; } /* '' */\n.icon-up-circled2:before { content: '\\e84e'; } /* '' */\n.icon-down-dir:before { content: '\\e84f'; } /* '' */\n.icon-up-dir:before { content: '\\e850'; } /* '' */\n.icon-left-dir:before { content: '\\e851'; } /* '' */\n.icon-right-dir:before { content: '\\e852'; } /* '' */\n.icon-down-open:before { content: '\\e853'; } /* '' */\n.icon-right-open:before { content: '\\e854'; } /* '' */\n.icon-left-open:before { content: '\\e855'; } /* '' */\n.icon-resize-full:before { content: '\\e856'; } /* '' */\n.icon-resize-small:before { content: '\\e857'; } /* '' */\n.icon-login:before { content: '\\e858'; } /* '' */\n.icon-folder:before { content: '\\e859'; } /* '' */\n.icon-folder-open:before { content: '\\e85a'; } /* '' */\n.icon-logout:before { content: '\\e85b'; } /* '' */\n.icon-up-open:before { content: '\\e85c'; } /* '' */\n.icon-down-big:before { content: '\\e85d'; } /* '' */\n.icon-left-big:before { content: '\\e85e'; } /* '' */\n.icon-right-big:before { content: '\\e85f'; } /* '' */\n.icon-up-big:before { content: '\\e860'; } /* '' */\n.icon-right-hand:before { content: '\\e861'; } /* '' */\n.icon-left-hand:before { content: '\\e862'; } /* '' */\n.icon-up-hand:before { content: '\\e863'; } /* '' */\n.icon-down-hand:before { content: '\\e864'; } /* '' */\n.icon-cw:before { content: '\\e865'; } /* '' */\n.icon-ccw:before { content: '\\e866'; } /* '' */\n.icon-arrows-cw:before { content: '\\e867'; } /* '' */\n.icon-shuffle:before { content: '\\e868'; } /* '' */\n.icon-play:before { content: '\\e869'; } /* '' */\n.icon-play-circled2:before { content: '\\e86a'; } /* '' */\n.icon-stop:before { content: '\\e86b'; } /* '' */\n.icon-pause:before { content: '\\e86c'; } /* '' */\n.icon-to-end:before { content: '\\e86d'; } /* '' */\n.icon-to-end-alt:before { content: '\\e86e'; } /* '' */\n.icon-to-start:before { content: '\\e86f'; } /* '' */\n.icon-to-start-alt:before { content: '\\e870'; } /* '' */\n.icon-fast-fw:before { content: '\\e871'; } /* '' */\n.icon-fast-bw:before { content: '\\e872'; } /* '' */\n.icon-eject:before { content: '\\e873'; } /* '' */\n.icon-target:before { content: '\\e874'; } /* '' */\n.icon-signal:before { content: '\\e875'; } /* '' */\n.icon-award:before { content: '\\e876'; } /* '' */\n.icon-inbox:before { content: '\\e877'; } /* '' */\n.icon-globe:before { content: '\\e878'; } /* '' */\n.icon-cloud:before { content: '\\e879'; } /* '' */\n.icon-flash:before { content: '\\e87a'; } /* '' */\n.icon-umbrella:before { content: '\\e87b'; } /* '' */\n.icon-flight:before { content: '\\e87c'; } /* '' */\n.icon-leaf:before { content: '\\e87d'; } /* '' */\n.icon-font:before { content: '\\e87e'; } /* '' */\n.icon-bold:before { content: '\\e87f'; } /* '' */\n.icon-italic:before { content: '\\e880'; } /* '' */\n.icon-text-height:before { content: '\\e881'; } /* '' */\n.icon-text-width:before { content: '\\e882'; } /* '' */\n.icon-align-left:before { content: '\\e883'; } /* '' */\n.icon-align-center:before { content: '\\e884'; } /* '' */\n.icon-align-right:before { content: '\\e885'; } /* '' */\n.icon-align-justify:before { content: '\\e886'; } /* '' */\n.icon-list:before { content: '\\e887'; } /* '' */\n.icon-indent-left:before { content: '\\e888'; } /* '' */\n.icon-indent-right:before { content: '\\e889'; } /* '' */\n.icon-scissors:before { content: '\\e88a'; } /* '' */\n.icon-briefcase:before { content: '\\e88b'; } /* '' */\n.icon-off:before { content: '\\e88c'; } /* '' */\n.icon-road:before { content: '\\e88d'; } /* '' */\n.icon-list-alt:before { content: '\\e88e'; } /* '' */\n.icon-qrcode:before { content: '\\e88f'; } /* '' */\n.icon-barcode:before { content: '\\e890'; } /* '' */\n.icon-book:before { content: '\\e891'; } /* '' */\n.icon-adjust:before { content: '\\e892'; } /* '' */\n.icon-tint:before { content: '\\e893'; } /* '' */\n.icon-check:before { content: '\\e894'; } /* '' */\n.icon-asterisk:before { content: '\\e895'; } /* '' */\n.icon-gift:before { content: '\\e896'; } /* '' */\n.icon-fire:before { content: '\\e897'; } /* '' */\n.icon-magnet:before { content: '\\e898'; } /* '' */\n.icon-chart-bar:before { content: '\\e899'; } /* '' */\n.icon-credit-card:before { content: '\\e89a'; } /* '' */\n.icon-floppy:before { content: '\\e89b'; } /* '' */\n.icon-megaphone:before { content: '\\e89c'; } /* '' */\n.icon-key:before { content: '\\e89d'; } /* '' */\n.icon-truck:before { content: '\\e89e'; } /* '' */\n.icon-hammer:before { content: '\\e89f'; } /* '' */\n.icon-move:before { content: '\\f047'; } /* '' */\n.icon-link-ext:before { content: '\\f08e'; } /* '' */\n.icon-check-empty:before { content: '\\f096'; } /* '' */\n.icon-bookmark-empty:before { content: '\\f097'; } /* '' */\n.icon-phone-squared:before { content: '\\f098'; } /* '' */\n.icon-rss:before { content: '\\f09e'; } /* '' */\n.icon-hdd:before { content: '\\f0a0'; } /* '' */\n.icon-certificate:before { content: '\\f0a3'; } /* '' */\n.icon-left-circled:before { content: '\\f0a8'; } /* '' */\n.icon-right-circled:before { content: '\\f0a9'; } /* '' */\n.icon-up-circled:before { content: '\\f0aa'; } /* '' */\n.icon-down-circled:before { content: '\\f0ab'; } /* '' */\n.icon-tasks:before { content: '\\f0ae'; } /* '' */\n.icon-filter:before { content: '\\f0b0'; } /* '' */\n.icon-resize-full-alt:before { content: '\\f0b2'; } /* '' */\n.icon-beaker:before { content: '\\f0c3'; } /* '' */\n.icon-docs:before { content: '\\f0c5'; } /* '' */\n.icon-menu:before { content: '\\f0c9'; } /* '' */\n.icon-list-bullet:before { content: '\\f0ca'; } /* '' */\n.icon-list-numbered:before { content: '\\f0cb'; } /* '' */\n.icon-strike:before { content: '\\f0cc'; } /* '' */\n.icon-underline:before { content: '\\f0cd'; } /* '' */\n.icon-table:before { content: '\\f0ce'; } /* '' */\n.icon-magic:before { content: '\\f0d0'; } /* '' */\n.icon-money:before { content: '\\f0d6'; } /* '' */\n.icon-columns:before { content: '\\f0db'; } /* '' */\n.icon-sort:before { content: '\\f0dc'; } /* '' */\n.icon-sort-down:before { content: '\\f0dd'; } /* '' */\n.icon-sort-up:before { content: '\\f0de'; } /* '' */\n.icon-mail-alt:before { content: '\\f0e0'; } /* '' */\n.icon-gauge:before { content: '\\f0e4'; } /* '' */\n.icon-comment-empty:before { content: '\\f0e5'; } /* '' */\n.icon-chat-empty:before { content: '\\f0e6'; } /* '' */\n.icon-sitemap:before { content: '\\f0e8'; } /* '' */\n.icon-paste:before { content: '\\f0ea'; } /* '' */\n.icon-lightbulb:before { content: '\\f0eb'; } /* '' */\n.icon-exchange:before { content: '\\f0ec'; } /* '' */\n.icon-download-cloud:before { content: '\\f0ed'; } /* '' */\n.icon-upload-cloud:before { content: '\\f0ee'; } /* '' */\n.icon-user-md:before { content: '\\f0f0'; } /* '' */\n.icon-stethoscope:before { content: '\\f0f1'; } /* '' */\n.icon-suitcase:before { content: '\\f0f2'; } /* '' */\n.icon-bell-alt:before { content: '\\f0f3'; } /* '' */\n.icon-coffee:before { content: '\\f0f4'; } /* '' */\n.icon-food:before { content: '\\f0f5'; } /* '' */\n.icon-doc-text:before { content: '\\f0f6'; } /* '' */\n.icon-building:before { content: '\\f0f7'; } /* '' */\n.icon-hospital:before { content: '\\f0f8'; } /* '' */\n.icon-ambulance:before { content: '\\f0f9'; } /* '' */\n.icon-medkit:before { content: '\\f0fa'; } /* '' */\n.icon-fighter-jet:before { content: '\\f0fb'; } /* '' */\n.icon-beer:before { content: '\\f0fc'; } /* '' */\n.icon-h-sigh:before { content: '\\f0fd'; } /* '' */\n.icon-plus-squared:before { content: '\\f0fe'; } /* '' */\n.icon-angle-double-left:before { content: '\\f100'; } /* '' */\n.icon-angle-double-right:before { content: '\\f101'; } /* '' */\n.icon-angle-double-up:before { content: '\\f102'; } /* '' */\n.icon-angle-double-down:before { content: '\\f103'; } /* '' */\n.icon-angle-left:before { content: '\\f104'; } /* '' */\n.icon-angle-right:before { content: '\\f105'; } /* '' */\n.icon-angle-up:before { content: '\\f106'; } /* '' */\n.icon-angle-down:before { content: '\\f107'; } /* '' */\n.icon-desktop:before { content: '\\f108'; } /* '' */\n.icon-laptop:before { content: '\\f109'; } /* '' */\n.icon-tablet:before { content: '\\f10a'; } /* '' */\n.icon-mobile:before { content: '\\f10b'; } /* '' */\n.icon-circle-empty:before { content: '\\f10c'; } /* '' */\n.icon-quote-left:before { content: '\\f10d'; } /* '' */\n.icon-quote-right:before { content: '\\f10e'; } /* '' */\n.icon-spinner:before { content: '\\f110'; } /* '' */\n.icon-circle:before { content: '\\f111'; } /* '' */\n.icon-reply:before { content: '\\f112'; } /* '' */\n.icon-folder-empty:before { content: '\\f114'; } /* '' */\n.icon-folder-open-empty:before { content: '\\f115'; } /* '' */\n.icon-smile:before { content: '\\f118'; } /* '' */\n.icon-frown:before { content: '\\f119'; } /* '' */\n.icon-meh:before { content: '\\f11a'; } /* '' */\n.icon-gamepad:before { content: '\\f11b'; } /* '' */\n.icon-keyboard:before { content: '\\f11c'; } /* '' */\n.icon-flag-empty:before { content: '\\f11d'; } /* '' */\n.icon-flag-checkered:before { content: '\\f11e'; } /* '' */\n.icon-terminal:before { content: '\\f120'; } /* '' */\n.icon-code:before { content: '\\f121'; } /* '' */\n.icon-reply-all:before { content: '\\f122'; } /* '' */\n.icon-star-half-alt:before { content: '\\f123'; } /* '' */\n.icon-direction:before { content: '\\f124'; } /* '' */\n.icon-crop:before { content: '\\f125'; } /* '' */\n.icon-fork:before { content: '\\f126'; } /* '' */\n.icon-unlink:before { content: '\\f127'; } /* '' */\n.icon-help:before { content: '\\f128'; } /* '' */\n.icon-info:before { content: '\\f129'; } /* '' */\n.icon-attention-alt:before { content: '\\f12a'; } /* '' */\n.icon-superscript:before { content: '\\f12b'; } /* '' */\n.icon-subscript:before { content: '\\f12c'; } /* '' */\n.icon-eraser:before { content: '\\f12d'; } /* '' */\n.icon-puzzle:before { content: '\\f12e'; } /* '' */\n.icon-mic:before { content: '\\f130'; } /* '' */\n.icon-mute:before { content: '\\f131'; } /* '' */\n.icon-shield:before { content: '\\f132'; } /* '' */\n.icon-calendar-empty:before { content: '\\f133'; } /* '' */\n.icon-extinguisher:before { content: '\\f134'; } /* '' */\n.icon-rocket:before { content: '\\f135'; } /* '' */\n.icon-angle-circled-left:before { content: '\\f137'; } /* '' */\n.icon-angle-circled-right:before { content: '\\f138'; } /* '' */\n.icon-angle-circled-up:before { content: '\\f139'; } /* '' */\n.icon-angle-circled-down:before { content: '\\f13a'; } /* '' */\n.icon-anchor:before { content: '\\f13d'; } /* '' */\n.icon-lock-open-alt:before { content: '\\f13e'; } /* '' */\n.icon-bullseye:before { content: '\\f140'; } /* '' */\n.icon-ellipsis:before { content: '\\f141'; } /* '' */\n.icon-ellipsis-vert:before { content: '\\f142'; } /* '' */\n.icon-rss-squared:before { content: '\\f143'; } /* '' */\n.icon-play-circled:before { content: '\\f144'; } /* '' */\n.icon-ticket:before { content: '\\f145'; } /* '' */\n.icon-minus-squared:before { content: '\\f146'; } /* '' */\n.icon-minus-squared-alt:before { content: '\\f147'; } /* '' */\n.icon-level-up:before { content: '\\f148'; } /* '' */\n.icon-level-down:before { content: '\\f149'; } /* '' */\n.icon-ok-squared:before { content: '\\f14a'; } /* '' */\n.icon-pencil-squared:before { content: '\\f14b'; } /* '' */\n.icon-link-ext-alt:before { content: '\\f14c'; } /* '' */\n.icon-export-alt:before { content: '\\f14d'; } /* '' */\n.icon-compass:before { content: '\\f14e'; } /* '' */\n.icon-expand:before { content: '\\f150'; } /* '' */\n.icon-collapse:before { content: '\\f151'; } /* '' */\n.icon-expand-right:before { content: '\\f152'; } /* '' */\n.icon-euro:before { content: '\\f153'; } /* '' */\n.icon-pound:before { content: '\\f154'; } /* '' */\n.icon-dollar:before { content: '\\f155'; } /* '' */\n.icon-rupee:before { content: '\\f156'; } /* '' */\n.icon-yen:before { content: '\\f157'; } /* '' */\n.icon-rouble:before { content: '\\f158'; } /* '' */\n.icon-won:before { content: '\\f159'; } /* '' */\n.icon-doc-inv:before { content: '\\f15b'; } /* '' */\n.icon-doc-text-inv:before { content: '\\f15c'; } /* '' */\n.icon-sort-name-up:before { content: '\\f15d'; } /* '' */\n.icon-sort-name-down:before { content: '\\f15e'; } /* '' */\n.icon-sort-alt-up:before { content: '\\f160'; } /* '' */\n.icon-sort-alt-down:before { content: '\\f161'; } /* '' */\n.icon-sort-number-up:before { content: '\\f162'; } /* '' */\n.icon-sort-number-down:before { content: '\\f163'; } /* '' */\n.icon-thumbs-up-alt:before { content: '\\f164'; } /* '' */\n.icon-thumbs-down-alt:before { content: '\\f165'; } /* '' */\n.icon-down:before { content: '\\f175'; } /* '' */\n.icon-up:before { content: '\\f176'; } /* '' */\n.icon-left:before { content: '\\f177'; } /* '' */\n.icon-right:before { content: '\\f178'; } /* '' */\n.icon-female:before { content: '\\f182'; } /* '' */\n.icon-male:before { content: '\\f183'; } /* '' */\n.icon-sun:before { content: '\\f185'; } /* '' */\n.icon-moon:before { content: '\\f186'; } /* '' */\n.icon-box:before { content: '\\f187'; } /* '' */\n.icon-bug:before { content: '\\f188'; } /* '' */\n.icon-right-circled2:before { content: '\\f18e'; } /* '' */\n.icon-left-circled2:before { content: '\\f190'; } /* '' */\n.icon-collapse-left:before { content: '\\f191'; } /* '' */\n.icon-dot-circled:before { content: '\\f192'; } /* '' */\n.icon-wheelchair:before { content: '\\f193'; } /* '' */\n.icon-try:before { content: '\\f195'; } /* '' */\n.icon-plus-squared-alt:before { content: '\\f196'; } /* '' */\n.icon-space-shuttle:before { content: '\\f197'; } /* '' */\n.icon-mail-squared:before { content: '\\f199'; } /* '' */\n.icon-bank:before { content: '\\f19c'; } /* '' */\n.icon-graduation-cap:before { content: '\\f19d'; } /* '' */\n.icon-language:before { content: '\\f1ab'; } /* '' */\n.icon-fax:before { content: '\\f1ac'; } /* '' */\n.icon-building-filled:before { content: '\\f1ad'; } /* '' */\n.icon-child:before { content: '\\f1ae'; } /* '' */\n.icon-paw:before { content: '\\f1b0'; } /* '' */\n.icon-spoon:before { content: '\\f1b1'; } /* '' */\n.icon-cube:before { content: '\\f1b2'; } /* '' */\n.icon-cubes:before { content: '\\f1b3'; } /* '' */\n.icon-recycle:before { content: '\\f1b8'; } /* '' */\n.icon-cab:before { content: '\\f1b9'; } /* '' */\n.icon-taxi:before { content: '\\f1ba'; } /* '' */\n.icon-tree:before { content: '\\f1bb'; } /* '' */\n.icon-database:before { content: '\\f1c0'; } /* '' */\n.icon-file-pdf:before { content: '\\f1c1'; } /* '' */\n.icon-file-word:before { content: '\\f1c2'; } /* '' */\n.icon-file-excel:before { content: '\\f1c3'; } /* '' */\n.icon-file-powerpoint:before { content: '\\f1c4'; } /* '' */\n.icon-file-image:before { content: '\\f1c5'; } /* '' */\n.icon-file-archive:before { content: '\\f1c6'; } /* '' */\n.icon-file-audio:before { content: '\\f1c7'; } /* '' */\n.icon-file-video:before { content: '\\f1c8'; } /* '' */\n.icon-file-code:before { content: '\\f1c9'; } /* '' */\n.icon-lifebuoy:before { content: '\\f1cd'; } /* '' */\n.icon-circle-notch:before { content: '\\f1ce'; } /* '' */\n.icon-rebel:before { content: '\\f1d0'; } /* '' */\n.icon-empire:before { content: '\\f1d1'; } /* '' */\n.icon-paper-plane:before { content: '\\f1d8'; } /* '' */\n.icon-paper-plane-empty:before { content: '\\f1d9'; } /* '' */\n.icon-history:before { content: '\\f1da'; } /* '' */\n.icon-circle-thin:before { content: '\\f1db'; } /* '' */\n.icon-header:before { content: '\\f1dc'; } /* '' */\n.icon-paragraph:before { content: '\\f1dd'; } /* '' */\n.icon-sliders:before { content: '\\f1de'; } /* '' */\n.icon-share:before { content: '\\f1e0'; } /* '' */\n.icon-share-squared:before { content: '\\f1e1'; } /* '' */\n.icon-bomb:before { content: '\\f1e2'; } /* '' */\n.icon-soccer-ball:before { content: '\\f1e3'; } /* '' */\n.icon-tty:before { content: '\\f1e4'; } /* '' */\n.icon-binoculars:before { content: '\\f1e5'; } /* '' */\n.icon-plug:before { content: '\\f1e6'; } /* '' */\n.icon-newspaper:before { content: '\\f1ea'; } /* '' */\n.icon-wifi:before { content: '\\f1eb'; } /* '' */\n.icon-calc:before { content: '\\f1ec'; } /* '' */\n.icon-bell-off:before { content: '\\f1f6'; } /* '' */\n.icon-bell-off-empty:before { content: '\\f1f7'; } /* '' */\n.icon-trash:before { content: '\\f1f8'; } /* '' */\n.icon-copyright:before { content: '\\f1f9'; } /* '' */\n.icon-at:before { content: '\\f1fa'; } /* '' */\n.icon-eyedropper:before { content: '\\f1fb'; } /* '' */\n.icon-brush:before { content: '\\f1fc'; } /* '' */\n.icon-birthday:before { content: '\\f1fd'; } /* '' */\n.icon-chart-area:before { content: '\\f1fe'; } /* '' */\n.icon-chart-pie:before { content: '\\f200'; } /* '' */\n.icon-chart-line:before { content: '\\f201'; } /* '' */\n.icon-toggle-off:before { content: '\\f204'; } /* '' */\n.icon-toggle-on:before { content: '\\f205'; } /* '' */\n.icon-bicycle:before { content: '\\f206'; } /* '' */\n.icon-bus:before { content: '\\f207'; } /* '' */\n.icon-shekel:before { content: '\\f20b'; } /* '' */\n.icon-cart-plus:before { content: '\\f217'; } /* '' */\n.icon-cart-arrow-down:before { content: '\\f218'; } /* '' */\n.icon-diamond:before { content: '\\f219'; } /* '' */\n.icon-ship:before { content: '\\f21a'; } /* '' */\n.icon-user-secret:before { content: '\\f21b'; } /* '' */\n.icon-motorcycle:before { content: '\\f21c'; } /* '' */\n.icon-street-view:before { content: '\\f21d'; } /* '' */\n.icon-heartbeat:before { content: '\\f21e'; } /* '' */\n.icon-venus:before { content: '\\f221'; } /* '' */\n.icon-mars:before { content: '\\f222'; } /* '' */\n.icon-mercury:before { content: '\\f223'; } /* '' */\n.icon-transgender:before { content: '\\f224'; } /* '' */\n.icon-transgender-alt:before { content: '\\f225'; } /* '' */\n.icon-venus-double:before { content: '\\f226'; } /* '' */\n.icon-mars-double:before { content: '\\f227'; } /* '' */\n.icon-venus-mars:before { content: '\\f228'; } /* '' */\n.icon-mars-stroke:before { content: '\\f229'; } /* '' */\n.icon-mars-stroke-v:before { content: '\\f22a'; } /* '' */\n.icon-mars-stroke-h:before { content: '\\f22b'; } /* '' */\n.icon-neuter:before { content: '\\f22c'; } /* '' */\n.icon-server:before { content: '\\f233'; } /* '' */\n.icon-user-plus:before { content: '\\f234'; } /* '' */\n.icon-user-times:before { content: '\\f235'; } /* '' */\n.icon-bed:before { content: '\\f236'; } /* '' */\n.icon-viacoin:before { content: '\\f237'; } /* '' */\n.icon-train:before { content: '\\f238'; } /* '' */\n.icon-subway:before { content: '\\f239'; } /* '' */\n.icon-medium:before { content: '\\f23a'; } /* '' */\n\n.pick-a-color-markup *{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}\n.pick-a-color-markup .hex-pound{padding-left:8px;padding-right:8px}@media screen and (max-width:991px){.pick-a-color-markup .hex-pound{padding:3px 5px 0px 5px;min-height:30px}}\n.pick-a-color-markup .pick-a-color{padding:5px}@media screen and (max-width:991px){.pick-a-color-markup .pick-a-color{width:100%;font-size:18px;padding:9px;min-width:222px;height:47px}}\n.pick-a-color-markup .input-group-btn .color-dropdown{padding:6px 5px}.pick-a-color-markup .input-group-btn .color-dropdown.no-hex{border-bottom-left-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .input-group-btn .color-dropdown:focus{background-color:#fff}\n@media screen and (max-width:991px){.pick-a-color-markup .input-group-btn .color-dropdown{height:47px}}\n.pick-a-color-markup .color-preview{border:1px solid #ccc;border-radius:4px;-webkit-box-shadow:inset 0 0 2px 2px rgba(0,0,0,0.075);box-shadow:inset 0 0 2px 2px rgba(0,0,0,0.075);height:1.429em;width:1.429em;display:inline-block;cursor:pointer;margin-right:5px}.pick-a-color-markup .color-preview.current-color{margin-bottom:-5px}\n@media screen and (max-width:991px){.pick-a-color-markup .color-preview{height:1.875em;width:1.875em}}\n.pick-a-color-markup .color-menu{text-align:left;padding:5px 0px;width:330px;font-size:14px;left:auto;}.pick-a-color-markup .color-menu.color-menu--inline{left:-285px}@media screen and (max-width:991px){.pick-a-color-markup .color-menu.color-menu--inline{left:-242px}}\n@media screen and (max-width:991px){.pick-a-color-markup .color-menu{left:-242px;width:293px}}.pick-a-color-markup .color-menu.small{width:100px}@media screen and (max-width:991px){.pick-a-color-markup .color-menu.small{left:-105px}}\n.pick-a-color-markup .color-menu.no-hex{left:0px}\n.pick-a-color-markup .color-menu ul{padding:0px;margin:0px}\n.pick-a-color-markup .color-menu li{list-style-type:none;padding:5px 0px;margin:0px}\n.pick-a-color-markup .color-menu .color-preview{vertical-align:middle;margin:0px}@media screen and (max-width:991px){.pick-a-color-markup .color-menu .color-preview{height:35px;width:35px}}.pick-a-color-markup .color-menu .color-preview.current-color,.pick-a-color-markup .color-menu .color-preview.white{background-color:#fff}\n.pick-a-color-markup .color-menu .color-preview.red{background-color:#f00}\n.pick-a-color-markup .color-menu .color-preview.orange{background-color:#f60}\n.pick-a-color-markup .color-menu .color-preview.yellow{background-color:#ff0}\n.pick-a-color-markup .color-menu .color-preview.green{background-color:#008000}\n.pick-a-color-markup .color-menu .color-preview.blue{background-color:#00f}\n.pick-a-color-markup .color-menu .color-preview.indigo{background-color:#4a0080}\n.pick-a-color-markup .color-menu .color-preview.violet{background-color:#ee81ee}\n.pick-a-color-markup .color-menu .color-preview.purple{background-color:#80007f}\n.pick-a-color-markup .color-menu .color-preview.black{background-color:#000}\n.pick-a-color-markup .color-menu .basicColors-content li>a,.pick-a-color-markup .color-menu .savedColors-content li>a{padding:5px 15px 3px 15px;cursor:default;min-height:25px;color:#333}.pick-a-color-markup .color-menu .basicColors-content li>a:hover,.pick-a-color-markup .color-menu .savedColors-content li>a:hover{background-color:#fff}\n@media screen and (max-width:991px){.pick-a-color-markup .color-menu .basicColors-content li>a,.pick-a-color-markup .color-menu .savedColors-content li>a{min-height:40px}}\n.pick-a-color-markup .color-menu .basicColors-content li:hover a,.pick-a-color-markup .color-menu .savedColors-content li:hover a{color:#333;background-image:none;filter:none;text-decoration:none;font-weight:bold}@media screen and (max-width:991px){.pick-a-color-markup .color-menu .basicColors-content li:hover a,.pick-a-color-markup .color-menu .savedColors-content li:hover a{background-color:#fff;font-weight:normal}}\n.pick-a-color-markup .color-menu .btn.color-select{margin:0px 5px;height:20px;padding:0px 5px;margin-top:0px;line-height:1.5px;border-radius:4px}@media screen and (max-width:991px){.pick-a-color-markup .color-menu .btn.color-select{height:35px}}\n.pick-a-color-markup .caret{margin-bottom:3px}\n.pick-a-color-markup .color-menu-instructions,.pick-a-color-markup .advanced-instructions{text-align:center;padding:0px 6px;margin:0px;font-size:14px;font-weight:normal}@media screen and (min-width:992px){.pick-a-color-markup .color-menu-instructions,.pick-a-color-markup .advanced-instructions{display:none}}\n.pick-a-color-markup .color-label{vertical-align:middle;margin:0px;margin-left:10px;cursor:pointer}@media screen and (max-width:991px){.pick-a-color-markup .color-label{margin-left:8px}}\n.pick-a-color-markup .color-box{height:20px;width:200px;position:absolute;left:115px;border:1px solid #ccc;border-radius:4px;-webkit-box-shadow:inset 0 0 2px 2px rgba(0,0,0,0.075);box-shadow:inset 0 0 2px 2px rgba(0,0,0,0.075);cursor:pointer}@media screen and (max-width:991px){.pick-a-color-markup .color-box{width:160px;height:35px}}\n.pick-a-color-markup .black .highlight-band-stripe{background-color:#fff}\n.pick-a-color-markup .spectrum-white{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#fff), to(#808080));background-image:-webkit-linear-gradient(left, color-stop(#fff 0), color-stop(#808080 100%));background-image:-moz-linear-gradient(left, #fff 0, #808080 100%);background-image:linear-gradient(to right, #fff 0, #808080 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ff808080', GradientType=1)}.pick-a-color-markup .spectrum-white .highlight-band{left:0px}\n.pick-a-color-markup .spectrum-red{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #fff), color-stop(.5, #f00), color-stop(1, #000));background-image:-moz-linear-gradient(left center, #fff 0, #f00 50%, #000 100%);background-image:-webkit-linear-gradient(left, #fff 0, #f00 50%, #000 100%);background-image:-o-linear-gradient(left, #fff 0, #f00 50%, #000 100%);background-image:linear-gradient(to right, #fff 0, #f00 50%, #000 100%);background-repeat:repeat-x}\n.pick-a-color-markup .spectrum-orange{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #fff), color-stop(.5, #f60), color-stop(1, #000));background-image:-moz-linear-gradient(left center, #fff 0, #f60 50%, #000 100%);background-image:-webkit-linear-gradient(left, #fff 0, #f60 50%, #000 100%);background-image:-o-linear-gradient(left, #fff 0, #f60 50%, #000 100%);background-image:linear-gradient(to right, #fff 0, #f60 50%, #000 100%);background-repeat:repeat-x}\n.pick-a-color-markup .spectrum-yellow{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #fff), color-stop(.5, #ff0), color-stop(1, #000));background-image:-moz-linear-gradient(left center, #fff 0, #ff0 50%, #000 100%);background-image:-webkit-linear-gradient(left, #fff 0, #ff0 50%, #000 100%);background-image:-o-linear-gradient(left, #fff 0, #ff0 50%, #000 100%);background-image:linear-gradient(to right, #fff 0, #ff0 50%, #000 100%);background-repeat:repeat-x}\n.pick-a-color-markup .spectrum-green{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #80ff80), color-stop(.5, #008000), color-stop(1, #000));background-image:-moz-linear-gradient(left center, #80ff80 0, #008000 50%, #000 100%);background-image:-webkit-linear-gradient(left, #80ff80 0, #008000 50%, #000 100%);background-image:-o-linear-gradient(left, #80ff80 0, #008000 50%, #000 100%);background-image:linear-gradient(to right, #80ff80 0, #008000 50%, #000 100%);background-repeat:repeat-x}\n.pick-a-color-markup .spectrum-blue{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #fff), color-stop(.5, #00f), color-stop(1, #000));background-image:-moz-linear-gradient(left center, #fff 0, #00f 50%, #000 100%);background-image:-webkit-linear-gradient(left, #fff 0, #00f 50%, #000 100%);background-image:-o-linear-gradient(left, #fff 0, #00f 50%, #000 100%);background-image:linear-gradient(to right, #fff 0, #00f 50%, #000 100%);background-repeat:repeat-x}\n.pick-a-color-markup .spectrum-purple{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #ff80ff), color-stop(.5, #80007f), color-stop(1, #000));background-image:-moz-linear-gradient(left center, #ff80ff 0, #80007f 50%, #000 100%);background-image:-webkit-linear-gradient(left, #ff80ff 0, #80007f 50%, #000 100%);background-image:-o-linear-gradient(left, #ff80ff 0, #80007f 50%, #000 100%);background-image:linear-gradient(to right, #ff80ff 0, #80007f 50%, #000 100%);background-repeat:repeat-x}\n.pick-a-color-markup .spectrum-black{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#000), to(#808080));background-image:-webkit-linear-gradient(left, color-stop(#000 0), color-stop(#808080 100%));background-image:-moz-linear-gradient(left, #000 0, #808080 100%);background-image:linear-gradient(to right, #000 0, #808080 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff000000', endColorstr='#ff808080', GradientType=1)}.pick-a-color-markup .spectrum-black .highlight-band{left:0px;border:1px solid #808080}\n.pick-a-color-markup .ie-spectrum{height:20px;width:100px;display:inline-block;top:-1}.pick-a-color-markup .ie-spectrum.hue{width:50.5px}@media screen and (max-width:991px){.pick-a-color-markup .ie-spectrum.hue{width:45.5px}}\n@media screen and (max-width:991px){.pick-a-color-markup .ie-spectrum{width:80px;height:35px}}\n.pick-a-color-markup .red-spectrum-0,.pick-a-color-markup .lightness-spectrum-0{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#fff), to(#f00));background-image:-webkit-linear-gradient(left, color-stop(#fff 0), color-stop(#f00 100%));background-image:-moz-linear-gradient(left, #fff 0, #f00 100%);background-image:linear-gradient(to right, #fff 0, #f00 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffff0000', GradientType=1);border-bottom-left-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .red-spectrum-1,.pick-a-color-markup .lightness-spectrum-1{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#f00), to(#000));background-image:-webkit-linear-gradient(left, color-stop(#f00 0), color-stop(#000 100%));background-image:-moz-linear-gradient(left, #f00 0, #000 100%);background-image:linear-gradient(to right, #f00 0, #000 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffff0000', endColorstr='#ff000000', GradientType=1);border-bottom-right-radius:4px;border-top-right-radius:4px}\n.pick-a-color-markup .lightness-spectrum-0,.pick-a-color-markup .lightness-spectrum-1{width:150px}@media screen and (max-width:991px){.pick-a-color-markup .lightness-spectrum-0,.pick-a-color-markup .lightness-spectrum-1{width:135px}}\n.pick-a-color-markup .orange-spectrum-0{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#fff), to(#f60));background-image:-webkit-linear-gradient(left, color-stop(#fff 0), color-stop(#f60 100%));background-image:-moz-linear-gradient(left, #fff 0, #f60 100%);background-image:linear-gradient(to right, #fff 0, #f60 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffff6600', GradientType=1);border-bottom-left-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .orange-spectrum-1{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#f60), to(#000));background-image:-webkit-linear-gradient(left, color-stop(#f60 0), color-stop(#000 100%));background-image:-moz-linear-gradient(left, #f60 0, #000 100%);background-image:linear-gradient(to right, #f60 0, #000 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffff6600', endColorstr='#ff000000', GradientType=1);border-bottom-right-radius:4px;border-top-right-radius:4px}\n.pick-a-color-markup .yellow-spectrum-0{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#fff), to(#ff0));background-image:-webkit-linear-gradient(left, color-stop(#fff 0), color-stop(#ff0 100%));background-image:-moz-linear-gradient(left, #fff 0, #ff0 100%);background-image:linear-gradient(to right, #fff 0, #ff0 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffffff00', GradientType=1);border-bottom-left-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .yellow-spectrum-1{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#ff0), to(#000));background-image:-webkit-linear-gradient(left, color-stop(#ff0 0), color-stop(#000 100%));background-image:-moz-linear-gradient(left, #ff0 0, #000 100%);background-image:linear-gradient(to right, #ff0 0, #000 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffff00', endColorstr='#ff000000', GradientType=1);border-bottom-right-radius:4px;border-top-right-radius:4px}\n.pick-a-color-markup .green-spectrum-0{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#80ff80), to(#008000));background-image:-webkit-linear-gradient(left, color-stop(#80ff80 0), color-stop(#008000 100%));background-image:-moz-linear-gradient(left, #80ff80 0, #008000 100%);background-image:linear-gradient(to right, #80ff80 0, #008000 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff80ff80', endColorstr='#ff008000', GradientType=1);border-bottom-left-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .green-spectrum-1{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#008000), to(#000));background-image:-webkit-linear-gradient(left, color-stop(#008000 0), color-stop(#000 100%));background-image:-moz-linear-gradient(left, #008000 0, #000 100%);background-image:linear-gradient(to right, #008000 0, #000 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff008000', endColorstr='#ff000000', GradientType=1);border-bottom-right-radius:4px;border-top-right-radius:4px}\n.pick-a-color-markup .blue-spectrum-0{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#fff), to(#00f));background-image:-webkit-linear-gradient(left, color-stop(#fff 0), color-stop(#00f 100%));background-image:-moz-linear-gradient(left, #fff 0, #00f 100%);background-image:linear-gradient(to right, #fff 0, #00f 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ff0000ff', GradientType=1);border-bottom-left-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .blue-spectrum-1{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#00f), to(#000));background-image:-webkit-linear-gradient(left, color-stop(#00f 0), color-stop(#000 100%));background-image:-moz-linear-gradient(left, #00f 0, #000 100%);background-image:linear-gradient(to right, #00f 0, #000 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0000ff', endColorstr='#ff000000', GradientType=1);border-bottom-right-radius:4px;border-top-right-radius:4px}\n.pick-a-color-markup .purple-spectrum-0{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#ff80ff), to(#80007f));background-image:-webkit-linear-gradient(left, color-stop(#ff80ff 0), color-stop(#80007f 100%));background-image:-moz-linear-gradient(left, #ff80ff 0, #80007f 100%);background-image:linear-gradient(to right, #ff80ff 0, #80007f 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffff80ff', endColorstr='#ff80007f', GradientType=1);border-bottom-left-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .purple-spectrum-1{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#80007f), to(#000));background-image:-webkit-linear-gradient(left, color-stop(#80007f 0), color-stop(#000 100%));background-image:-moz-linear-gradient(left, #80007f 0, #000 100%);background-image:linear-gradient(to right, #80007f 0, #000 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff80007f', endColorstr='#ff000000', GradientType=1);border-bottom-right-radius:4px;border-top-right-radius:4px}\n.pick-a-color-markup .saturation-spectrum-0{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#808080), to(#bf4040));background-image:-webkit-linear-gradient(left, color-stop(#808080 0), color-stop(#bf4040 100%));background-image:-moz-linear-gradient(left, #808080 0, #bf4040 100%);background-image:linear-gradient(to right, #808080 0, #bf4040 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff808080', endColorstr='#ffbf4040', GradientType=1);border-bottom-left-radius:4px;border-top-left-radius:4px;width:150px}@media screen and (max-width:991px){.pick-a-color-markup .saturation-spectrum-0{width:135px}}\n.pick-a-color-markup .saturation-spectrum-1{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#bf4040), to(#f00));background-image:-webkit-linear-gradient(left, color-stop(#bf4040 0), color-stop(#f00 100%));background-image:-moz-linear-gradient(left, #bf4040 0, #f00 100%);background-image:linear-gradient(to right, #bf4040 0, #f00 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffbf4040', endColorstr='#ffff0000', GradientType=1);border-bottom-right-radius:4px;border-top-right-radius:4px;width:150px}@media screen and (max-width:991px){.pick-a-color-markup .saturation-spectrum-1{width:135px}}\n.pick-a-color-markup .hue-spectrum-0{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#f00), to(#ff0));background-image:-webkit-linear-gradient(left, color-stop(#f00 0), color-stop(#ff0 100%));background-image:-moz-linear-gradient(left, #f00 0, #ff0 100%);background-image:linear-gradient(to right, #f00 0, #ff0 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffff0000', endColorstr='#ffffff00', GradientType=1)}\n.pick-a-color-markup .hue-spectrum-1{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#ff0), to(#0f0));background-image:-webkit-linear-gradient(left, color-stop(#ff0 0), color-stop(#0f0 100%));background-image:-moz-linear-gradient(left, #ff0 0, #0f0 100%);background-image:linear-gradient(to right, #ff0 0, #0f0 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffff00', endColorstr='#ff00ff00', GradientType=1)}\n.pick-a-color-markup .hue-spectrum-2{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#0f0), to(#0ff));background-image:-webkit-linear-gradient(left, color-stop(#0f0 0), color-stop(#0ff 100%));background-image:-moz-linear-gradient(left, #0f0 0, #0ff 100%);background-image:linear-gradient(to right, #0f0 0, #0ff 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff00ff00', endColorstr='#ff00ffff', GradientType=1);left:-1px;position:relative}\n.pick-a-color-markup .hue-spectrum-3{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#0ff), to(#00f));background-image:-webkit-linear-gradient(left, color-stop(#0ff 0), color-stop(#00f 100%));background-image:-moz-linear-gradient(left, #0ff 0, #00f 100%);background-image:linear-gradient(to right, #0ff 0, #00f 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff00ffff', endColorstr='#ff0000ff', GradientType=1);left:-1px;position:relative}\n.pick-a-color-markup .hue-spectrum-4{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#00f), to(#f0f));background-image:-webkit-linear-gradient(left, color-stop(#00f 0), color-stop(#f0f 100%));background-image:-moz-linear-gradient(left, #00f 0, #f0f 100%);background-image:linear-gradient(to right, #00f 0, #f0f 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0000ff', endColorstr='#ffff00ff', GradientType=1);left:-1px;position:relative}\n.pick-a-color-markup .hue-spectrum-5{background-image:-webkit-gradient(linear, 0 top, 100% top, from(#f0f), to(#f00));background-image:-webkit-linear-gradient(left, color-stop(#f0f 0), color-stop(#f00 100%));background-image:-moz-linear-gradient(left, #f0f 0, #f00 100%);background-image:linear-gradient(to right, #f0f 0, #f00 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffff00ff', endColorstr='#ffff0000', GradientType=1);left:-2px;position:relative}\n.pick-a-color-markup .highlight-band{border:1px solid #222;border-radius:2px;-webkit-box-shadow:1px 1px 1px #333;box-shadow:1px 1px 1px #333;height:19px;width:11px;display:inline-block;cursor:pointer;cursor:-webkit-grab;cursor:-moz-grab;position:absolute;top:-1px;left:94.5px;text-align:center}@media screen and (max-width:991px){.pick-a-color-markup .highlight-band{width:21px;left:69.5px;height:34px}}\n.pick-a-color-markup .highlight-band-stripe{min-height:80%;min-width:1px;background-color:#000;opacity:0.40;margin:2px 1px;display:inline-block;-webkit-box-shadow:1px 0 2px 0 #fff;box-shadow:1px 0 2px 0 #fff}@media screen and (max-width:991px){.pick-a-color-markup .highlight-band-stripe{margin:4px 2px}}\n.pick-a-color-markup .color-menu-tabs{padding:5px 3px 3px 10px;font-size:12px;color:#333;border-bottom:1px solid #ccc;margin-bottom:5px}.pick-a-color-markup .color-menu-tabs .tab{padding:4px 5px;margin:5px;border-left:1px solid #fff;border-right:1px solid #fff;cursor:pointer;background-color:#fff}.pick-a-color-markup .color-menu-tabs .tab:hover{padding-bottom:6px;border-top:1px solid #ccc;border-right:1px solid #ccc;border-left:1px solid #ccc;border-top-right-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .color-menu-tabs a{color:#333;text-decoration:none}\n.pick-a-color-markup .color-menu-tabs .tab-active{border-bottom:3px solid #fff;padding-bottom:5px;border-top:1px solid #ccc;border-right:1px solid #ccc;border-left:1px solid #ccc;border-top-right-radius:4px;border-top-left-radius:4px}\n.pick-a-color-markup .active-content{display:block}\n.pick-a-color-markup .inactive-content{display:none}\n.pick-a-color-markup .savedColors-content{padding:5px 15px;white-space:normal}.pick-a-color-markup .savedColors-content li.color-item>a{margin-left:7px;padding-left:8px;border-radius:4px}\n.pick-a-color-markup .saved-color-col{position:relative;left:-15px;float:left;width:149px}@media screen and (max-width:991px){.pick-a-color-markup .saved-color-col{width:130px}}\n.pick-a-color-markup .advanced-content ul{margin-top:10px}\n.pick-a-color-markup .advanced-content li{padding:5px 15px 3px 15px;cursor:default;min-height:25px;height:50px;position:relative}@media screen and (max-width:991px){.pick-a-color-markup .advanced-content li{min-height:70px}}\n.pick-a-color-markup .advanced-content .color-preview{height:50px;width:300px;float:left;margin:0px 0px 10px 0px;background-color:#f00;text-align:center}.pick-a-color-markup .advanced-content .color-preview .color-select.btn.advanced{margin-top:15px;display:none}@media screen and (max-width:991px){.pick-a-color-markup .advanced-content .color-preview .color-select.btn.advanced{display:inline;margin-top:7px}}\n.pick-a-color-markup .advanced-content .color-preview:hover .color-select.btn.advanced{display:inline}\n@media screen and (max-width:991px){.pick-a-color-markup .advanced-content .color-preview{width:270px;margin-left:-10px}}\n.pick-a-color-markup .advanced-content .spectrum-hue{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #f00), color-stop(17%, #ff0), color-stop(34%, #0f0), color-stop(51%, #0ff), color-stop(68%, #00f), color-stop(85%, #f0f), color-stop(100%, #f00));background-image:-moz-linear-gradient(left center, #f00 0, #ff0 17%, #0f0 24%, #0ff 51%, #00f 68%, #f0f 85%, #f00 100%);background-image:-webkit-linear-gradient(left, #f00 0, #ff0 17%, #0f0 24%, #0ff 51%, #00f 68%, #f0f 85%, #f00 100%);background-image:-o-linear-gradient(left, #f00 0, #ff0 17%, #0f0 24%, #0ff 51%, #00f 68%, #f0f 85%, #f00 100%);background-image:linear-gradient(to right, #f00 0, #ff0 17%, #0f0 24%, #0ff 51%, #00f 68%, #f0f 85%, #f00 100%);background-repeat:repeat-x}.pick-a-color-markup .advanced-content .spectrum-hue .highlight-band{left:0px}\n.pick-a-color-markup .advanced-content .spectrum-lightness{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #fff), color-stop(.5, #f00), color-stop(1, #000));background-image:-moz-linear-gradient(left center, #fff 0, #f00 50%, #000 100%);background-image:-webkit-linear-gradient(left, #fff 0, #f00 50%, #000 100%);background-image:-o-linear-gradient(left, #fff 0, #f00 50%, #000 100%);background-image:linear-gradient(to right, #fff 0, #f00 50%, #000 100%);background-repeat:repeat-x}\n.pick-a-color-markup .advanced-content .spectrum-saturation{background-image:-webkit-gradient(linear, left top, right top, color-stop(0, #808080), color-stop(.5, #f00), color-stop(1, #f00));background-image:-moz-linear-gradient(left center, #808080 0, #f00 50%, #f00 100%);background-image:-webkit-linear-gradient(left, #808080 0, #f00 50%, #f00 100%);background-image:-o-linear-gradient(left, #808080 0, #f00 50%, #f00 100%);background-image:linear-gradient(to right, #808080 0, #f00 50%, #f00 100%);background-repeat:repeat-x}.pick-a-color-markup .advanced-content .spectrum-saturation .highlight-band{left:287px}@media screen and (max-width:991px){.pick-a-color-markup .advanced-content .spectrum-saturation .highlight-band{left:247px}}\n.pick-a-color-markup .advanced-content .spectrum-lightness .highlight-band{left:143.5px}@media screen and (max-width:991px){.pick-a-color-markup .advanced-content .spectrum-lightness .highlight-band{left:123.5px}}\n.pick-a-color-markup .advanced-content .lightness-text,.pick-a-color-markup .advanced-content .hue-text,.pick-a-color-markup .advanced-content .saturation-text,.pick-a-color-markup .advanced-content .preview-text{vertical-align:middle;text-align:center;display:block}\n.pick-a-color-markup .advanced-content .color-box{left:15px;top:25px;width:300px}@media screen and (max-width:991px){.pick-a-color-markup .advanced-content .color-box{width:270px;left:10px}}\n.pick-a-color-markup .advanced-content .preview-item{height:80px}\n@-moz-document url-prefix(){@media screen and (max-width:991px){div.pick-a-color-markup .color-menu{left:0px}}}\n\n.rte_toolBar .rte-custom-icon > span,\n.rte_toolBar .rte-custom-icon > span:after {\n height: 19px;\n width: 16px;\n display: inline-block;\n margin-bottom: -4px;\n}\n\n.icon-textNumbered, .icon-textNumbered:after {\n content: url(\"../../rte/gui/components/clientlibs/core/resources/List_ordered.svg\");\n}\n\n.icon-textLetteredUppercase, .icon-textLetteredUppercase:after {\n content: url(\"../../rte/gui/components/clientlibs/core/resources/List_caps_a.svg\");\n}\n\n.icon-textLetteredLowercase, .icon-textLetteredLowercase:after {\n content: url(\"../../rte/gui/components/clientlibs/core/resources/List_a.svg\");\n}\n\n.icon-textRomanUppercase, .icon-textRomanUppercase:after {\n content: url(\"../../rte/gui/components/clientlibs/core/resources/List_caps_i.svg\");\n}\n\n.icon-textRomanLowercase, .icon-textRomanLowercase:after {\n content: url(\"../../rte/gui/components/clientlibs/core/resources/List_i.svg\");\n}\n\n.rte_toolBar{\n all: initial;\n position: absolute;\n display: none;\n -webkit-box-shadow: 0 2px 6px 0 rgba(0,0,0,0.15);\n -moz-box-shadow: 0 2px 6px 0 rgba(0,0,0,0.15);\n box-shadow: 0 2px 6px 0 rgba(0,0,0,0.15);\n background-color: white;\n font-family: Helvetica,Arial,sans-serif;\n}\n\n.forms-richTextEditor.rte-mode-full {\n position: fixed;\n display: flex;\n flex-direction: column;\n top: 10vh;\n left: 10vw;\n background-color: #FFFFFF;\n width: 80vw;\n height: 80vh;\n z-index: 99999;\n border: 1px solid rgba(0,0,0,0.1);\n border-radius: 4px;\n -webkit-box-shadow: 0 4px 20px 0 rgba(0,0,0,0.2);\n -moz-box-shadow: 0 4px 20px 0 rgba(0,0,0,0.2);\n box-shadow: 0 4px 20px 0 rgba(0,0,0,0.2);\n}\n\n.forms-richTextEditor.rte-mode-full .rte_toolBar {\n display: block !important;\n flex: 0 1 auto;\n position: relative;\n top: auto !important;\n left: auto !important;\n background-color: rgb(240,240,240);\n box-shadow: none;\n}\n\n.forms-richTextEditor.rte-mode-basic .rte_toolBar {\n display: inline-block;\n z-index: 10000;\n}\n\n.forms-richTextEditor .wysihtml5-editor {\n overflow: auto;\n}\n.forms-richTextEditor.rte-mode-full .wysihtml5-editor {\n padding: 1rem !important;\n width: calc(100% - 2rem) !important;\n height: calc(100% - 3.3rem) !important;\n border: none !important;\n position: relative !important;\n top: 0 !important;\n left: 0 !important;\n flex: 1 1 auto;\n}\n\n.rte_toolBar .popover {\n margin: 0;\n padding: 0;\n border: 1px solid rgb(200, 200, 200);\n border-radius: 0.25rem;\n background-color: white;\n max-width: none;\n position: absolute;\n top: 0;\n left: 0;\n z-index: 1010;\n display: none;\n text-align: left;\n background-clip: padding-box;\n white-space: normal;\n box-shadow: 0 1px 4px 0 rgba(0,0,0,0.2);\n}\n\n.rte_toolBar .popover > .arrow {\n display: none;\n}\n\n.rte_toolBar .popover > .popover-content {\n padding: 0;\n}\n\n.rte_toolBar .dropdown-menu {\n position: absolute;\n top: 100%;\n left: 0;\n z-index: 1000;\n display: none;\n float: left;\n min-width: 160px;\n padding: 5px 0;\n margin: 2px 0 0;\n list-style: none;\n font-size: 14px;\n background-color: #ffffff;\n border: 1px solid rgba(0, 0, 0, 0.15);\n border-radius: 4px;\n -webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);\n box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);\n background-clip: padding-box;\n}\n\n/****** Button styling **********/\n.rte_toolBar button.rte-button {\n all: initial;\n font-family: Helvetica,Arial,sans-serif;\n display: inline-block;\n padding: 0 1rem;\n margin: 0 1px;\n font-size: 16px;\n font-weight: normal;\n line-height: 2.5rem;\n text-align: center;\n white-space: nowrap;\n vertical-align: middle;\n -ms-touch-action: manipulation;\n touch-action: manipulation;\n cursor: pointer;\n -webkit-user-select: none;\n -moz-user-select: none;\n -ms-user-select: none;\n user-select: none;\n background-image: none;\n border: none;\n\n}\n\n.rte_toolBar button.rte-button.rte-button-quiet {\n color: #333;\n background-color: transparent;\n}\n\n.rte_toolBar button.rte-button.rte-button-square {\n background-color: white;\n border: 1px solid rgba(0,0,0,0.2);\n border-radius: 4px;\n padding: 0 0.8rem;\n color: #333;\n}\n\n.rte_toolBar button.rte-button.rte-button-quiet:hover,\n.rte_toolBar button.rte-button.rte-button-quiet:focus,\n.rte_toolBar button.rte-button.rte-button-quiet:active {\n color: #333;\n background-color: #FAFAFA;\n box-shadow: inset 1px 0 0 0 rgba(0,0,0,0.2), inset -1px 0 0 0 rgba(0,0,0,0.2);\n}\n\n\n/************ Popover stylings **************/\n\n.rte_toolBar .rte-popover {\n\tdisplay: inline-block;\n}\n\n.rte_toolBar .rte-popover > button:after {\n content: '';\n display: inline-block;\n width: 0;\n height: 0;\n border-bottom: 8px solid rgba(0,0,0,0.2);\n border-left: 10px solid transparent;\n margin-bottom: -1rem;\n margin-right: -1rem;\n}\n\n\n/*********** Group styles *******************/\n.rte_toolBar .rte-group {\n display: inline;\n}\n\n.rte_toolBar .rte-group:after {\n content: '';\n display: inline;\n width: 1px;\n height: 2rem;\n background-color: rgba(0,0,0,0.2);\n vertical-align: middle;\n}\n\n.rte_toolBar .rte-block-group {\n display: block;\n}\n/*********** Dropdown styles *******************/\n.rte_toolBar .rte-select {\n display: inline;\n}\n.rte_toolBar .rte-select > select {\n margin-right: 5px;\n height: 2.5rem;\n padding: 0.5rem 2rem 0.5rem 0.5rem;;\n color: #555;\n background-color: transparent;\n background-image: none;\n border: none;\n -webkit-transition: border-color ease-in-out .15s, -webkit-box-shadow ease-in-out .15s;\n -o-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;\n transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;\n -webkit-appearance: none;\n -moz-appearance: none;\n appearance: none;\n width: auto;\n cursor: pointer;\n position: relative;\n z-index: 1;\n}\n\n.rte_toolBar .rte-select > i {\n margin-left: -2rem;\n font-size: 11px;\n pointer-events : none;\n position: relative;\n}\n\n\n/************* Input styles ***********/\n.rte_toolBar .rte-numberInput {\n display: inline-block;\n max-width: 6rem;\n margin-right: 0.5rem;\n}\n\n.rte_toolBar .rte-input,\n.rte_toolBar .rte-numberInput > input {\n all: initial;\n height: 1.5rem;\n padding: 0.5rem;\n border: 1px solid rgba(0,0,0,0.2);\n font-family: Helvetica,Arial,sans-serif;\n}\n\n.rte_toolBar .rte-numberInput > input {\n width: 85%;\n}\n\n.rte_toolBar input[type=\"checkbox\"] {\n width: auto !important;\n height: auto !important;\n}\n\n/******* Color Picker stylings *********/\n.rte_toolBar .rte-colorInput {\n display: inline-block;\n margin-right: 0.5rem;\n}\n\n.rte_toolBar .rte-colorInput button {\n border-radius: 0 !important;\n}\n\n.rte_toolBar .rte-colorInput .pick-a-color-markup .color-dropdown:focus,\n.rte_toolBar .rte-colorInput .pick-a-color-markup .color-dropdown:active,\n.rte_toolBar .rte-colorInput .pick-a-color-markup .color-dropdown:hover {\n color: #333;\n background-color: #FAFAFA;\n box-shadow: inset 1px 0 0 0 rgba(0,0,0,0.2), inset -1px 0 0 0 rgba(0,0,0,0.2);\n}\n.rte_toolBar .rte-colorInput .pick-a-color-markup .color-preview {\n border: 1px solid rgba(0,0,0,.1);\n box-shadow: none;\n border-radius: 0;\n margin: 0;\n vertical-align: middle;\n}\n\n.rte_toolBar .rte-colorInput .pick-a-color-markup .highlight-band {\n background-color: #fff;\n border-radius: 0;\n border: .0625rem solid #c8c8c8;\n width: .625rem;\n height: 1.5rem;\n top: -0.5rem;\n box-shadow: none;\n}\n\n.rte_toolBar .rte-colorInput .pick-a-color-markup .highlight-band-stripe {\n display: none;\n}\n\n.rte_toolBar .rte-colorInput .pick-a-color-markup .color-box {\n height: 8px;\n border-top: .0625rem solid rgba(0,0,0,.1);\n border-bottom: .0625rem solid rgba(0,0,0,.1);\n zoom: 1;\n margin-top: 0.4rem;\n}\n\n.rte_toolBar .rte-colorInput .pick-a-color-markup .color-menu.no-hex {\n left: auto !important;\n}\n\n.rte_toolBar .rte-colorInput button {\n all: initial;\n border-radius: 0px;\n padding: 6px 5px;\n font-family: Helvetica,Arial,sans-serif;\n line-height: 1.7rem;\n}\n\n\n\n.rte_toolBar .rte_insertLink_dialog,\n.rte_toolBar .rte_findAndReplace_dialog {\n padding: 0.5rem;\n}\n\n.rte_toolBar .rte_insertLink_dialog {\n width: 25.8rem;\n}\n\n.rte_toolBar .rte_insertLink_dialog > span{\n display: inline-block;\n margin-top: 1rem;\n}\n\n.rte_toolBar .rte_insertLink_dialog > button{\n margin: 0.5rem 0.1rem;\n float: right;\n}\n\n.rte_toolBar .rte_lists_command + .popover {\n width: 9rem;\n}\n\n.rte_toolBar .input-group,\n.rte_toolBar .input-group-btn {\n display: inline-block;\n}\n\n.wysihtml5-tempContainer {\n height: 0;\n overflow: hidden;\n}\n/*************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n **************************************************************************/\n\n/* this works only for MWS app. In IE behavior remains same\n with horizontal scrollbar appearing for content-width greater than device-width */\n@-ms-viewport{\n width: device-width;\n}\n\n.formLoading{\n text-align: center;\n vertical-align: middle;\n background-color: white;\n height:100%;\n width:100%;\n}\n\n.xfaform {\n position: relative;\n}\n\n\ninput:not([type=\"radio\"]),select,textarea {\n border: 0;\n padding: 0;\n margin: 0;\n -webkit-border-radius: 0;\n -moz-border-radius: 0;\n background-color: rgba(255,255,255,0);\n}\n\ninput[type=\"radio\"] {\n padding: 0px;\n margin: 0px;\n}\n\n.widgetError {\n background-color: #D3D3D3 !important;\n}\n\n.widgetMandatoryBorder {\n outline: 1.5px solid red;\n}\n\n.dataInvalid {\n outline: 2px solid orange;\n}\n\n#xfa_ui_freeze {\n position: fixed;\n left: 0;\n right: 0;\n top: 0;\n bottom: 0;\n width: 100%;\n height: 100%;\n background-color: rgba(0, 0, 0, 0.3); /*dim the background*/\n cursor: wait !important; /* busy cursor */\n z-index: 100000;\n}\n\ninput:focus, textarea:focus{\n outline: none;\n cursor: auto;\n}\n\ninput[readonly=\"readonly\"][type=\"text\"]:focus, textarea[readonly=\"readonly\"]:focus, input[type=\"radio\"]:focus, input[type=\"checkbox\"]:focus, select:focus, .imagefieldwidget > img:focus, .listBoxWidget > ol > li:focus {\n outline: #000000 dashed 1px;\n}\n\ninput[type=\"button\"]:focus {\n outline: #000000 dashed 2px;\n}\n\n.page {\n background-color: rgba(255,255,255,1);\n filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#ffffffff,endColorstr=#ffffffff);\n overflow: hidden;\n}\n\n/*#######################################################################*/\n/*# Html-XFA Layout specific styles */\n/*#######################################################################*/\n\n.page > div, .field > div, .draw > * {\n position: absolute\n}\n\n/* must exclude date picker icons from aligning to top left*/\ntable .field > *, table .draw > *, table .field div > *:not(.datepicker-calendar-icon) {\n top: 0;\n left: 0;\n}\n\n/* LC-5561 : Override the 1em extra line space between paragraphs introduced by browser user agent */\n.draw p {\nmargin-top: 0px;\nmargin-bottom: 0px;\n}\n\n/*####################################### Html-XFA Layout specific styles End ##################### */\n\n.subform {\n overflow: visible;\n}\n\ndiv.widget > textarea , table.widget > textarea\n{\n resize: none;\n overflow: hidden;\n}\n\n\n\nsvg|rect\n{\n fill-opacity: 0.0\n}\n\nsvg|text\n{\n white-space: pre;\n -webkit-text-size-adjust: auto;\n}\n\nsvg|tspan\n{\n white-space: pre;\n -webkit-text-size-adjust: auto;\n}\n\ninput[type=date]::-webkit-outer-spin-button {\n -webkit-appearance: none;\n}\n\ninput[type=date]::-webkit-inner-spin-button {\n -webkit-appearance: none;\n}\n\n.neutral {\n opacity: 0.5;\n filter: alpha(opacity=50);\n}\n\n#error-msg {\n background-color: #ee0101;\n z-index:990;\n display:none;\n position:absolute;\n opacity:0.85;\n color:#FFFFFF;\n font-size: 21px;\n border: 2px solid #ddd;\n box-shadow: 0 0 6px #000;\n -moz-box-shadow: 0 0 6px #000;\n -webkit-box-shadow: 0 0 6px #000;\n padding: 4px 10px 4px 10px;\n border-radius: 6px;\n -moz-border-radius: 6px;\n -webkit-border-radius: 6px;\n}\n\n#warning-msg {\n background-color: #FFA500;\n z-index:990;\n display:none;\n position:absolute;\n opacity:0.85;\n color:#FFFFFF;\n font-size: 21px;\n border: 2px solid #ddd;\n box-shadow: 0 0 6px #000;\n -moz-box-shadow: 0 0 6px #000;\n -webkit-box-shadow: 0 0 6px #000;\n padding: 4px 10px 4px 10px;\n border-radius: 6px;\n -moz-border-radius: 6px;\n -webkit-border-radius: 6px;\n}\n\ninput[type=\"button\"]:active {\n background-color: rgba(0,0,0,0.21)\n}\n\n.dateTimeEdit input\n{\n width:100%;\n height:100%;\n}\n.hideElement {\n\tvisibility: hidden !important;\n}\n\n/*************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n **************************************************************************/\n\n\n\n#msgBox_container {\n font-family: Arial, sans-serif;\n font-size: 12px;\n min-width: 300px; /* Dialog will be no smaller than this */\n max-width: 600px; /* Dialog will wrap after this width */\n background: #FFF;\n border: solid 5px #999;\n color: #000;\n -moz-border-radius: 5px;\n -webkit-border-radius: 5px;\n border-radius: 5px;\n}\n\n#msgBox_title {\n font-size: 14px;\n font-weight: bold;\n text-align: center;\n line-height: 1.75em;\n color: #666;\n background: #CCC top repeat-x;\n border: solid 1px #FFF;\n border-bottom: solid 1px #999;\n cursor: default;\n padding: 0em;\n margin: 0em;\n}\n\n#msgBox_content {\n background: 16px 16px no-repeat ;\n padding: 1em 1.75em;\n margin: 0em;\n}\n\n#msgBox_message {\n padding-left: 48px;\n}\n\n#msgBox_panel {\n text-align: center;\n margin: 1em 0em 0em 1em;\n}\n\n#msgBox_prompt {\n margin: .5em 0em;\n}\n\ninput#msgBox_Ok,input#msgBox_Yes,input#msgBox_No,input#msgBox_Cancel{\n background-color: buttonFace;\n padding: 5px 10px;\n -webkit-box-shadow: rgba(0,0,0,1) 0 1px 0;\n -moz-box-shadow: rgba(0,0,0,1) 0 1px 0;\n box-shadow: rgba(0,0,0,1) 0 1px 0;\n text-shadow: rgba(0,0,0,.4) 0 1px 0;\n color: buttonText;\n font-size: 14px;\n font-family: Georgia, serif;\n text-decoration: none;\n vertical-align: middle;\n outline:none;\n border: 2px outset buttonface;\n}\n\ninput#msgBox_Ok:focus,input#msgBox_Yes:focus,input#msgBox_No:focus,input#msgBox_Cancel:focus{\noutline:highlight;\n}\n\ninput#msgBox_Ok:hover,input#msgBox_Yes:hover,input#msgBox_No:hover,input#msgBox_Cancel:hover{\noutline:none;\nborder: 2px outset buttonface;\n}\n.msgBoxType0{\n background-image: url(../../../../etc.clientlibs/fd/xfaforms/clientlibs/xfalib/resources/images/A_Warning_Lg_N.png);\n}\n.msgBoxType1{\n background-image: url(../../../../etc.clientlibs/fd/xfaforms/clientlibs/xfalib/resources/images/A_Alert2_Lg_N.png);\n}\n.msgBoxType2{\n background-image: url(../../../../etc.clientlibs/fd/xfaforms/clientlibs/xfalib/resources/images/C_QuestionBubble_Xl_N.png);\n}\n.msgBoxType3{\n background-image: url(../../../../etc.clientlibs/fd/xfaforms/clientlibs/xfalib/resources/images/A_InfoBlue_32x32_N.png);\n}\n\n/*************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n **************************************************************************/\n\n.datetimepicker {\n border: none;\n background-color: #FFF;\n display: none;\n position: absolute;\n cursor: default;\n z-index: 100;\n outline: solid #CCCCCC 2px;\n}\n\n.datetimepicker .dp-clear {\n overflow: auto;\n background-color: #F5F5F5;\n text-align: center;\n}\n\n.datetimepicker .dp-clear a {\n cursor: pointer;\n height: 40px;\n line-height: 40px;\n padding: 0px 5px 0px 5px;\n text-align: center;\n display: inline-block;\n font-size: 0.875rem;\n color: #969696;\n}\n\n.datetimepicker-notouch .dp-close a:hover {\n color: #c8bbff;\n}\n\n.datetimepicker .dp-header {\n height: 40px;\n line-height: 40px;\n color: #555555;\n margin-bottom: 5px;\n background-color: #E6E6E6;\n}\n\n.datetimepicker .dp-header .dp-leftnav,\n.datetimepicker .dp-header .dp-rightnav,\n.datetimepicker .dp-header .dp-caption {\n float: left;\n text-align: center;\n cursor: pointer;\n height: 40px;\n}\n\n.datetimepicker-notouch .dp-header .dp-caption:not(.disabled):hover {\n color: #969696;\n}\n\n.datetimepicker .dp-header .dp-rightnav {\n float: right;\n background: url(xfalib/resources/images/rightnav.png) no-repeat center center;\n width: 40px;\n}\n\n.datetimepicker .dp-header .dp-leftnav {\n width: 40px;\n background: url(xfalib/resources/images/leftnav.png) no-repeat center center;\n}\n\n.datetimepicker .dp-header .dp-rightnav:hover {\n background: url(xfalib/resources/images/rightnav_hover.png) no-repeat center center;\n}\n\n.datetimepicker .dp-header .dp-leftnav:hover {\n background: url(xfalib/resources/images/leftnav_hover.png) no-repeat center center;\n}\n\n.datetimepicker .view {\n display: none;\n}\n\n.datetimepicker .view ul {\n display: block;\n list-style: none;\n margin: 0px;\n padding: 0px;\n overflow: hidden;\n box-sizing: border-box;\n -moz-box-sizing: border-box;\n}\n\n.datetimepicker .view ul li {\n float: left;\n padding: 0px;\n text-align: center;\n border: none;\n box-sizing: border-box;\n -moz-box-sizing: border-box;\n color: #666666;\n}\n\n.datetimepicker .view ul.header li {\n color: #555555;\n}\n\n.datetimepicker .view ul:not(.header) li:not(.disabled) {\n cursor: pointer;\n}\n\n.datetimepicker .view ul.header {\n color: #000;\n background-color: #FFF;\n border-bottom: #E6E6E6 1px solid;\n}\n\n.datetimepicker-notouch .view ul:not(.header) li:not(.disabled):hover {\n color: black;\n background-color: #E6E6E6;\n opacity: 0.5;\n}\n\n.datetimepicker .view ul li.disabled {\n color: #CCCCCC;\n}\n\n.datetimepicker .view ul li.dp-selected {\n outline: none;\n background-color: #666666;\n color: #FFFFFF;\n opacity: 1.0;\n}\n\n.datetimepicker .view ul li.dp-focus {\n border: 1px dashed black;\n}\n\n.datepicker-calendar-icon {\n position: absolute;\n top: 0;\n right: 0;\n z-index: 10;\n height: 100%;\n background: url(xfalib/resources/images/calendar.png) no-repeat center center;\n background-size: contain;\n}\n\n.datefieldwidget.widgetreadonly .datepicker-calendar-icon {\n display: none;\n}\n\n/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2015 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n\n/** Default style to show placeholder in dropdownlist **/\n.dropDownList .placeHolder{\n color: gray;\n}\n\n.dropDownList select {\n width: 100%;\n height: 100%;\n}\n\n/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n\n\n\ndiv#iEBox_container {\n font-family: Arial, sans-serif;\n font-size: 12px;\n min-width: 300px; /* Dialog will be no smaller than this */\n /* Dialog will wrap after this width */\n background: #FFF;\n border: solid 2px #999;\n color: #000;\n \n \n -moz-border-radius: 10px;\n -webkit-border-radius: 10px;\n border-radius: 10px;\n \n display:none;\n /* the shadow */\n -moz-box-shadow: 10px 10px 5px #888888;\n -webkit-box-shadow: 10px 10px 5px #888888;\n box-shadow: 0px 0px 15px #888888;\n \n /* make dialog a non-selectatable thing */\n -moz-user-select: none; \n -khtml-user-select: none; \n -webkit-user-select: none; \n -o-user-select: none; \n \n position: absolute;\n z-index: 99998;\n padding: 0;\n margin: 0;\n\t \n\t line-height:0;\n}\n\n#iEBox_title {\n font-size: 14px;\n font-weight: normal;\n text-align: center;\n line-height: 1.75em;\n color: #555555;\n background: #FFFFFF top repeat-x;\n cursor: default;\n padding: 10px;\n margin: 0em;\n display:inline-block;\n /* border-left:2px ridge gray; */\n vertical-align:middle;\n}\n\n#iEBox_content {\n background: 16px 16px no-repeat ;\n padding: 10px 10px;\n margin: 0em;\n\tmin-width:300px;\n}\n\n#iEBox_canvas {\n border:4px #AAAAAA dashed;\n -ms-touch-action:pinch-zoom;\n touch-action:pinch-zoom;\n}\n\n#iEBox_panel {\n text-align: center;\n margin: 0em 0em 0em 0em;\n background-color:black;\n \n -moz-border-top-right-radius: 8px;\n -webkit-border-top-right-radius: 8px;\n border-top-right-radius: 8px;\n -moz-border-top-left-radius: 8px;\n -webkit-border-top-left-radius: 8px;\n border-top-left-radius: 8px;\n \n overflow:hidden;\n \n /* title bar color */\n background: #AFB0B5;\n\t\n -ms-touch-action:pinch-zoom;\n touch-action:pinch-zoom;\n}\n\n#iEBox_prompt {\n margin: .5em 0em;\n}\n\ndiv.iEBox_button {\n background:no-repeat;\n width:40px;\n height:40px;\n background-size:40px 40px;\n display:inline-block;\n margin:10px;\n}\ndiv#iEBox_Geo{\n background-image:url('xfalib/resources/images/iEBox_geo.png');\n width:40px;\n height:40px;\n background-size:40px 40px;\n display:none;\n vertical-align:middle;\n}\ndiv#iEBox_Text{\n background-image:url('xfalib/resources/images/iEBox_keyboard.png');\n width:40px;\n height:40px;\n background-size:40px 40px;\n display:inline-block;\n vertical-align:middle;\n}\n#keyboard_Sign_Box{\n border:4px #AAAAAA dashed;\n display:none;\n margin:0px;\n border-bottom:0px;\n border-radius: 0px 0px 0px 0px;\n outline:none;\n}\n\n#keyboard_Sign_Box::placeholder {\n font: 1rem sans-serif, Georgia;\n vertical-align: middle;\n}\n\ndiv#iEBox_Brush{\n background-image:url('xfalib/resources/images/iEBox_brush.png');\n width:40px;\n height:40px;\n background-size:40px 40px;\n\n vertical-align:middle;\n}\ndiv#iEBox_incBrush{\n background-image:url('xfalib/resources/images/iEBox_geo.png');\n width:40px;\n height:40px;\n background-size:40px 40px;\n \n vertical-align:middle;\n}\ndiv#iEBox_Ok {\n background-image:url('xfalib/resources/images/iEBox_ok.png');\n vertical-align:middle;\n float:right;\n}\ndiv#iEBox_Clear {\n background-image:url('xfalib/resources/images/iEBox_clear.png');\n vertical-align:middle;\n}\ndiv#iEBox_Cancel {\n background: url('xfalib/resources/images/iEBox_close.png') center no-repeat;\n float:right;\n}\ndiv#iEBox_moveframe{\npadding:0px;\nmargin:0px;\n border:0px dotted rgba(0,0,0,0.5);\n -moz-border-radius: 10px;\n -webkit-border-radius: 10px;\n border-radius: 10px;\n \n -moz-box-shadow: 10px 10px 5px #888888;\n -webkit-box-shadow: 10px 10px 5px #888888;\n box-shadow: 0px 0px 15px #888888;\n \n display:none;\n position:absolute;\n}\ndiv.disable_button {\n filter: url(\"data:image/svg+xml;utf8,#grayscale\"); /* Firefox 3.5+ */\n filter: grayscale(100%);\n -webkit-filter: grayscale(100%);\n -moz-filter: grayscale(100%);\n -ms-filter: grayscale(100%);\n -o-filter: grayscale(100%);\n}\ndiv.sc_popUpMenu {\n display:none;\n width:20px;\n height:20px;\n background:no-repeat;\n background-size:20px 20px; \n background-image:url('xfalib/resources/images/iEBox_no.png');\n \n z-index:9999;\n position:absolute;\n left:0px;\n top:0px;\n}\ndiv#iEBox_brushList{\n position:absolute;\n z-index:99999;\n background-color:white;\n -moz-box-shadow: 10px 10px 5px #888888;\n -webkit-box-shadow: 10px 10px 5px #888888;\n box-shadow: 0px 0px 15px #888888;\n display:none;\n}\ndiv#iEBox_brushList div:hover{\n background-color:gray;\n}\nfieldset#iEBox_caption {\n border:4px dashed #AAAAAA;\n border-bottom:0px;\n border-left:0px;\n border-right:0px;\n margin-right:4px;\n margin-left:1px;\n margin-top:0px;\n text-align:center;\n padding:0px;\n}\nfieldset#iEBox_caption > legend {\n width:auto;\n background-color: #FFFFFF;\n padding: 2px;\n}\n.emptyScribble {\n background: url(xfalib/resources/images/signature.png) no-repeat;\n}\n\ndiv#iEBox_canvases {\n white-space:nowrap;\n}\n\n/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n\ndiv .listBoxWidget , table.listBoxWidget{\n overflow: auto;\n}\n\ndiv.listBoxWidget > ol, table.listBoxWidget > ol{\n list-style-type: none;\n padding: 5px;\n margin:0px;\n outline: none;\n}\n\nol > li.item-selectable{\n background-color: rgba(255, 255, 255, 0);\n color: black;\n padding-left: 5px;\n cursor: pointer;\n}\n\nol> li.item-selected{\n background: #99C1DA;\n color: white;\n padding-left: 5px;\n cursor: pointer;\n}\n/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2017 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n\n.filePreview {\n position: absolute;\n top: -1000px;\n bottom: -1000px;\n visibility: hidden;\n height: 0;\n}\n\n/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2019 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n\n\n.richTextWidget {\n overflow: auto;\n}\n\n/*/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2023 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n\ntext {\n forced-color-adjust: auto;\n}\n\n@media (forced-colors: active) {\n\n text {\n fill:CanvasText!important;\n }\n\n a text {\n fill:LinkText!important;\n forced-color-adjust: auto;\n }\n\n input {\n color:CanvasText!important;\n }\n\n input([type=checkbox]) {\n color:Highlight!important;\n }\n\n\n .datetimepicker .dp-header {\n color:CanvasText!important;\n }\n \n .datetimepicker li {\n color:CanvasText!important;\n }\n \n .datetimepicker .dp-clear a {\n color:CanvasText!important;\n }\n \n .datetimepicker {\n background-color:Canvas!important;\n }\n \n .datetimepicker .dp-header{\n background-color:Canvas!important;\n }\n \n .datetimepicker .dp-header{\n background-color:Canvas!important;\n }\n \n .datetimepicker .dp-monthview {\n background-color:Canvas!important;\n }\n \n .datetimepicker .dp-yearview {\n background-color:Canvas!important;\n }\n \n .datetimepicker .dp-yearsetview {\n background-color:Canvas!important;\n }\n\n .datetimepicker .dp-monthview .header{\n background-color:Canvas!important;\n }\n \n .datetimepicker .dp-clear {\n background-color:Canvas!important;\n }\n}\n\n@media (forced-colors: active) and (prefers-color-scheme: dark) {\n\t.datepicker-calendar-icon {\n\t\tfilter: grayscale(100%) brightness(10)!important;\n\t}\n}\n/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n.toolbarheader {\n width: 100%;\n height: 39px;\n background-repeat: repeat-x;\n background-color: #C790F4;\n position: fixed;\n border: 1px solid rgba(0,0,0, 0.5);\n vertical-align: middle;\n z-index: 2;\n margin-bottom: 5px;\n position: relative;\n}\n\n.toolbarformslogo {\n background: url(\"toolbar/resources/images/AX_Form_Lg_N.png\") no-repeat;\n width: 28px;\n height: 28px;\n border: none;\n margin-top:5px;\n vertical-align: middle;\n float: left;\n}\n\n.toolbarfieldhighlight {\n background: url(\"toolbar/resources/images/AX_HighlightFields_Lg_N.png\") no-repeat;\n width: 50px;\n height: 28px;\n margin-top:5px;\n border: none;\n vertical-align: middle;\n float: right;\n /*border: 1px solid #ffffff;*/\n}\n.toolbarfileattachment {\n background: url(\"toolbar/resources/images/Attach.png\") no-repeat;\n width: 35px;\n height: 32px;\n margin-top:5px;\n border: none;\n vertical-align: middle;\n float: right;\n margin-right: 10px;\n /*border: 1px solid #ffffff;*/\n}\n.toolbarlogger {\n background-color: #C790F4 ;\n width: 120px;\n height: 28px;\n margin-top:5px;\n border: none;\n vertical-align: middle;\n float: right;\n text-align:center;\n}\n\n.toolbartext {\n font-family: Arial, Helvetica;\n font-size: 12px;\n}\n\n.widgetBackGroundColorHighlight:not(.widgetreadonly) {\n background-color: #DEE3FF !important;\n}\n\n.widgetBackGroundColorHighlight:not(.widgetreadonly):not(.widgetMandatoryBorder):not(.dataInvalid) {\n outline: none ;\n}\n\n#loadingPage {\n background: url(\"toolbar/resources/images/busy-state.gif\") no-repeat fixed center;\n position: fixed;\n left: 0;\n right: 0;\n top: 0;\n bottom: 0;\n width: 100%;\n height: 100%;\n background-color: rgb(255, 255, 255);\n cursor: wait; /* busy cursor */\n z-index: 100000;\n}\n\n.loadingBody {\n background-color: rgb(255, 255, 255);\n}\n\n#loadText {\n position: fixed;\n left: 50%;\n top: 50%;\n transform: translate(-50%, 35px);\n font-size: 150%;\n z-index: 1000000;\n}\n\ninput[type=\"file\"] {\n visibility: hidden !important;\n top: -2000px !important;\n left: -2000px !important;\n position: absolute !important;\n}\ninput[type=\"file\"] {\n display: block;\n}\n.guideFieldWidget input[type=\"button\"], .guideFieldWidget button, .guideFieldWidget .button {\n /* margin-top: @label-line-height * @label-font-size + @label-margin; */\n box-sizing: border-box;\n cursor: pointer;\n border-style: outset;\n border-width: 0px;\n border-color: #285e8e;\n color: #000000;\n background-color: #DDDDDD;\n padding: 10px 15px 10px 15px;\n font-size: 14px;\n line-height: normal;\n border-radius: 0;\n}\n\n\nul.guide-fu-fileItemList {\n padding-left: 0px;\n margin:0px;\n list-style: none;\n}\n\nli.guide-fu-fileItem{\n display: block;\n padding: 10px;\n background-color: #fff;\n border-top: 1px solid #dddddd;;\n color: #000000;\n}\n\nspan.guide-fu-filePreview{\n margin-right: 10px;\n float: left;\n color: #000000;\n}\n\nspan.guide-fu-fileName {\n text-decoration: underline;\n cursor: pointer;\n}\n\nspan.non-preview-fileName{\n text-decoration: none;\n opacity: 0.4;\n}\n\ndiv.guide-fu-comment[contenteditable=\"true\"] {\n border: 1px solid;\n margin-top:5px;\n}\n\ndiv.guide-fu-comment {\nwidth:100%;\nheight: 25px;\nmargin-top: 5px;\npadding: 2px 30px 2px 5px;\nword-break: break-word;\nborder-style: groove;\n}\n\n.modal-elements-font-size {\n font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n font-size: 14px;\n line-height: 1.42857143;\n color: #333333;\n}\ndiv.guideFileUpload div.guideFieldWidget > input[type=\"file\"] {\n visibility:hidden !important;\n top:-2000px !important;\n left:-2000px !important;\n position:absolute !important;\n}\n.fade {\n opacity: 0;\n -webkit-transition: opacity 0.15s linear;\n transition: opacity 0.15s linear;\n}\n.fade.in {\n opacity: 1;\n}\n.collapse {\n display: none;\n}\n.collapse.in {\n display: block;\n}\n.collapsing {\n position: relative;\n height: 0;\n overflow: hidden;\n -webkit-transition: height 0.35s ease;\n transition: height 0.35s ease;\n}\n.close {\n float: right;\n font-size: 21px;\n font-weight: bold;\n line-height: 1;\n color: #000000;\n text-shadow: 0 1px 0 #ffffff;\n opacity: 0.2;\n filter: alpha(opacity=20);\n}\n.close:hover,\n.close:focus {\n color: #000000;\n text-decoration: none;\n cursor: pointer;\n opacity: 0.5;\n filter: alpha(opacity=50);\n}\nbutton.close {\n padding: 0;\n cursor: pointer;\n background: transparent;\n border: 0;\n -webkit-appearance: none;\n}\n.modal-open {\n overflow: hidden;\n}\n.modal {\n display: none;\n overflow: auto;\n overflow-y: scroll;\n position: fixed;\n top: 0;\n right: 0;\n bottom: 0;\n left: 0;\n z-index: 1050;\n -webkit-overflow-scrolling: touch;\n outline: 0;\n}\n.modal.fade .modal-dialog {\n -webkit-transform: translate(0, -25%);\n -ms-transform: translate(0, -25%);\n transform: translate(0, -25%);\n -webkit-transition: -webkit-transform 0.3s ease-out;\n -moz-transition: -moz-transform 0.3s ease-out;\n -o-transition: -o-transform 0.3s ease-out;\n transition: transform 0.3s ease-out;\n}\n.modal.in .modal-dialog {\n -webkit-transform: translate(0, 0);\n -ms-transform: translate(0, 0);\n transform: translate(0, 0);\n}\n.modal-dialog {\n position: relative;\n width: auto;\n margin: 10px;\n}\n.modal-content {\n position: relative;\n background-color: #ffffff;\n border: 1px solid #999999;\n border: 1px solid rgba(0, 0, 0, 0.2);\n border-radius: 6px;\n -webkit-box-shadow: 0 3px 9px rgba(0, 0, 0, 0.5);\n box-shadow: 0 3px 9px rgba(0, 0, 0, 0.5);\n background-clip: padding-box;\n outline: none;\n}\n.modal-backdrop {\n position: fixed;\n top: 0;\n right: 0;\n bottom: 0;\n left: 0;\n z-index: 1040;\n background-color: #000000;\n}\n.modal-backdrop.fade {\n opacity: 0;\n filter: alpha(opacity=0);\n}\n.modal-backdrop.in {\n opacity: 0.5;\n filter: alpha(opacity=50);\n}\n.modal-header {\n padding: 15px;\n border-bottom: 1px solid #e5e5e5;\n min-height: 16.42857143px;\n}\n.modal-header .close {\n margin-top: -2px;\n}\n.modal-title {\n margin: 0;\n line-height: 1.42857143;\n}\n.modal-body {\n position: relative;\n padding: 20px;\n}\n.modal-footer {\n margin-top: 15px;\n padding: 19px 20px 20px;\n text-align: right;\n border-top: 1px solid #e5e5e5;\n}\n.modal-footer .btn + .btn {\n margin-left: 5px;\n margin-bottom: 0;\n}\n.modal-footer .btn-group .btn + .btn {\n margin-left: -1px;\n}\n.modal-footer .btn-block + .btn-block {\n margin-left: 0;\n}\n@media (min-width: 768px) {\n .modal-dialog {\n width: 600px;\n margin: 30px auto;\n }\n .modal-content {\n -webkit-box-shadow: 0 5px 15px rgba(0, 0, 0, 0.5);\n box-shadow: 0 5px 15px rgba(0, 0, 0, 0.5);\n }\n .modal-sm {\n width: 300px;\n }\n}\n@media (min-width: 992px) {\n .modal-lg {\n width: 900px;\n }\n}\n\n/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n\n.pagingfooter {\n width: 100%;\n height: 39px;\n background-repeat: repeat-x;\n background-color: #C790F4;\n border: 1px solid rgba(0,0,0, 0.5);\n vertical-align: middle;\n z-index: 2;\n margin-bottom: 5px;\n position: relative;\n}\n.pageloadinglogo {\n border: none;\n margin-right:5px;\n vertical-align: middle;\n}\n\n.pageloadtext {\n font-family: Arial, Helvetica;\n font-size: 12px;\n font-style: italic;\n}\n\n.pageloadnow {\n width: 200px;\n height: 28px;\n margin-top:5px;\n border: none;\n vertical-align: middle;\n float: right;\n border: none;\n\n}\n/*\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2012-2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and may be covered by U.S. and Foreign Patents,\n * patents in process, and are protected by trade secret or copyright law.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n *\n */\n.toolbarformsportalbtn{\n width: 45px;\n height: 35px;\n margin-top:5px;\n vertical-align: middle;\n float: right;\n text-align:center;\n padding: 5px;\n background: url('../../fp/components/clientlibs/xfaforms/resources/save.png') no-repeat transparent 0 0;\n border: none;\n}\n.fpsavemessage{\n width: 200px;\n height: 35px;\n margin-top: 45px;\n margin-right: -115px;\n vertical-align: middle;\n float: right;\n text-align: center;\n border: none;\n background: #D4D4D4;\n border-radius: 5px;\n font: 20px/24px Adobe Clean, Arial;\n padding: 10px 5px 5px 5px;\n display:none;\n}\n/*******************************************************************************\n * ADOBE CONFIDENTIAL\n * ___________________\n *\n * Copyright 2013 Adobe Systems Incorporated\n * All Rights Reserved.\n *\n * NOTICE: All information contained herein is, and remains\n * the property of Adobe Systems Incorporated and its suppliers,\n * if any. The intellectual and technical concepts contained\n * herein are proprietary to Adobe Systems Incorporated and its\n * suppliers and are protected by all applicable intellectual property\n * laws, including trade secret and copyright laws.\n * Dissemination of this information or reproduction of this material\n * is strictly forbidden unless prior written permission is obtained\n * from Adobe Systems Incorporated.\n ******************************************************************************/\n\nbody {\n margin: 0;\n padding: 0;\n background-color: #444;\n}\n\n\n", "headers" : { "X-Content-Type-Options" : "nosniff", - "Last-Modified" : "Sat, 03 May 2025 13:59:40 GMT", - "Date" : "Sun, 11 May 2025 11:23:44 GMT", + "Set-Cookie" : "cq-authoring-mode=TOUCH; Path=/; Expires=Sun, 23-Nov-2025 14:26:31 GMT; Max-Age=604800", + "Last-Modified" : "Thu, 18 Sep 2025 12:51:32 GMT", + "Expires" : "Thu, 01 Jan 1970 00:00:00 GMT", + "Date" : "Sun, 16 Nov 2025 14:26:31 GMT", "Content-Type" : "text/css;charset=utf-8" } }, - "uuid" : "3e90f2cb-315a-4083-a77d-c94479894815", + "uuid" : "1a4d3741-e8fd-426c-ad01-e05ab57658fd", "persistent" : true, - "insertionIndex" : 22 + "insertionIndex" : 36 } \ No newline at end of file diff --git a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_profile_js.json b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_profile_js.json index cc0fa072..cfbd51c2 100644 --- a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_profile_js.json +++ b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_fd_xfaforms_clientlibs_profile_js.json @@ -1,5 +1,5 @@ { - "id" : "0d679342-fffe-4666-9286-bd35cc64a58e", + "id" : "0a024c8e-aa5e-4459-91bf-531695e412fe", "name" : "etc.clientlibs_fd_xfaforms_clientlibs_profile.js", "request" : { "url" : "/etc.clientlibs/fd/xfaforms/clientlibs/profile.js", @@ -7,15 +7,15 @@ }, "response" : { "status" : 200, - "base64Body" : "/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */
!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}S.fn=S.prototype={jquery:f,constructor:S,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(n){return this.pushStack(S.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(S.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},S.extend=S.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(S.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||S.isPlainObject(n)?n:{},i=!1,a[t]=S.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},S.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){b(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(p(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(p(Object(e))?S.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(p(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:y}),"function"==typeof Symbol&&(S.fn[Symbol.iterator]=t[Symbol.iterator]),S.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var d=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,S="sizzle"+1*new Date,p=n.document,k=0,r=0,m=ue(),x=ue(),A=ue(),N=ue(),j=function(e,t){return e===t&&(l=!0),0},D={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",F=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",B=new RegExp(M+"+","g"),$=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="<a id='"+S+"'></a><select id='"+S+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!=C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&D.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(j),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(B," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[k,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[k,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[S]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace($,"$1"));return s[S]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[k,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[S]||(e[S]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===k&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[S]&&(v=Ce(v)),y&&!y[S]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[S]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace($,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace($," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=A[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[S]?i.push(a):o.push(a);(a=A(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=k+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t==C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument==C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(k=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(k=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=S.split("").sort(j).join("")===S,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);S.find=d,S.expr=d.selectors,S.expr[":"]=S.expr.pseudos,S.uniqueSort=S.unique=d.uniqueSort,S.text=d.getText,S.isXMLDoc=d.isXML,S.contains=d.contains,S.escapeSelector=d.escape;var h=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&S(e).is(n))break;r.push(e)}return r},T=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},k=S.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1<i.call(n,e)!==r}):S.filter(n,e,r)}S.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?S.find.matchesSelector(r,e)?[r]:[]:S.find.matches(e,S.grep(t,function(e){return 1===e.nodeType}))},S.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(S(e).filter(function(){for(t=0;t<r;t++)if(S.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)S.find(e,i[t],n);return 1<r?S.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&k.test(e)?S(e):e||[],!1).length}});var D,q=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(S.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&S(e);if(!k.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&S.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?S.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(S(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(S.uniqueSort(S.merge(this.get(),S(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),S.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return h(e,"parentNode")},parentsUntil:function(e,t,n){return h(e,"parentNode",n)},next:function(e){return O(e,"nextSibling")},prev:function(e){return O(e,"previousSibling")},nextAll:function(e){return h(e,"nextSibling")},prevAll:function(e){return h(e,"previousSibling")},nextUntil:function(e,t,n){return h(e,"nextSibling",n)},prevUntil:function(e,t,n){return h(e,"previousSibling",n)},siblings:function(e){return T((e.parentNode||{}).firstChild,e)},children:function(e){return T(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(A(e,"template")&&(e=e.content||e),S.merge([],e.childNodes))}},function(r,i){S.fn[r]=function(e,t){var n=S.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=S.filter(t,n)),1<this.length&&(H[r]||S.uniqueSort(n),L.test(r)&&n.reverse()),this.pushStack(n)}});var P=/[^\x20\t\r\n\f]+/g;function R(e){return e}function M(e){throw e}function I(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}S.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},S.each(e.match(P)||[],function(e,t){n[t]=!0}),n):S.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){S.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return S.each(arguments,function(e,t){var n;while(-1<(n=S.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<S.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},S.extend({Deferred:function(e){var o=[["notify","progress",S.Callbacks("memory"),S.Callbacks("memory"),2],["resolve","done",S.Callbacks("once memory"),S.Callbacks("once memory"),0,"resolved"],["reject","fail",S.Callbacks("once memory"),S.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return S.Deferred(function(r){S.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,R,s),l(u,o,M,s)):(u++,t.call(e,l(u,o,R,s),l(u,o,M,s),l(u,o,R,o.notifyWith))):(a!==R&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){S.Deferred.exceptionHook&&S.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==M&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(S.Deferred.getStackHook&&(t.stackTrace=S.Deferred.getStackHook()),C.setTimeout(t))}}return S.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:R,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:R)),o[2][3].add(l(0,e,m(n)?n:M))}).promise()},promise:function(e){return null!=e?S.extend(e,a):a}},s={};return S.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=S.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(I(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)I(i[t],a(t),o.reject);return o.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;S.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&W.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},S.readyException=function(e){C.setTimeout(function(){throw e})};var F=S.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),S.ready()}S.fn.ready=function(e){return F.then(e)["catch"](function(e){S.readyException(e)}),this},S.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--S.readyWait:S.isReady)||(S.isReady=!0)!==e&&0<--S.readyWait||F.resolveWith(E,[S])}}),S.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(S.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var $=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)$(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(S(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},_=/^-ms-/,z=/-([a-z])/g;function U(e,t){return t.toUpperCase()}function X(e){return e.replace(_,"ms-").replace(z,U)}var V=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function G(){this.expando=S.expando+G.uid++}G.uid=1,G.prototype={cache:function(e){var t=e[this.expando];return t||(t={},V(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[X(t)]=n;else for(r in t)i[X(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][X(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(X):(t=X(t))in r?[t]:t.match(P)||[]).length;while(n--)delete r[t[n]]}(void 0===t||S.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!S.isEmptyObject(t)}};var Y=new G,Q=new G,J=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,K=/[A-Z]/g;function Z(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(K,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:J.test(i)?JSON.parse(i):i)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}S.extend({hasData:function(e){return Q.hasData(e)||Y.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return Y.access(e,t,n)},_removeData:function(e,t){Y.remove(e,t)}}),S.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=Q.get(o),1===o.nodeType&&!Y.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=X(r.slice(5)),Z(o,r,i[r]));Y.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){Q.set(this,n)}):$(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=Q.get(o,n))?t:void 0!==(t=Z(o,n))?t:void 0;this.each(function(){Q.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){Q.remove(this,e)})}}),S.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Y.get(e,t),n&&(!r||Array.isArray(n)?r=Y.access(e,t,S.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=S.queue(e,t),r=n.length,i=n.shift(),o=S._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){S.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Y.get(e,n)||Y.access(e,n,{empty:S.Callbacks("once memory").add(function(){Y.remove(e,[t+"queue",n])})})}}),S.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?S.queue(this[0],t):void 0===n?this:this.each(function(){var e=S.queue(this,t,n);S._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&S.dequeue(this,t)})},dequeue:function(e){return this.each(function(){S.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=S.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Y.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var ee=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,te=new RegExp("^(?:([+-])=|)("+ee+")([a-z%]*)$","i"),ne=["Top","Right","Bottom","Left"],re=E.documentElement,ie=function(e){return S.contains(e.ownerDocument,e)},oe={composed:!0};re.getRootNode&&(ie=function(e){return S.contains(e.ownerDocument,e)||e.getRootNode(oe)===e.ownerDocument});var ae=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&ie(e)&&"none"===S.css(e,"display")};function se(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return S.css(e,t,"")},u=s(),l=n&&n[3]||(S.cssNumber[t]?"":"px"),c=e.nodeType&&(S.cssNumber[t]||"px"!==l&&+u)&&te.exec(S.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)S.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,S.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ue={};function le(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Y.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&ae(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ue[s])||(o=a.body.appendChild(a.createElement(s)),u=S.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ue[s]=u)))):"none"!==n&&(l[c]="none",Y.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}S.fn.extend({show:function(){return le(this,!0)},hide:function(){return le(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){ae(this)?S(this).show():S(this).hide()})}});var ce,fe,pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="<option></option>",y.option=!!ce.lastChild;var ge={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Y.set(e[n],"globalEval",!t||Y.get(t[n],"globalEval"))}ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td,y.option||(ge.optgroup=ge.option=[1,"<select multiple='multiple'>","</select>"]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))S.merge(p,o.nodeType?[o]:o);else if(me.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+S.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;S.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<S.inArray(o,r))i&&i.push(o);else if(l=ie(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}var be=/^([^.]*)(?:\.(.+)|)/;function we(){return!0}function Te(){return!1}function Ce(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ee(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ee(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Te;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return S().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=S.guid++)),e.each(function(){S.event.add(this,t,i,r,n)})}function Se(e,i,o){o?(Y.set(e,i,!1),S.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Y.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(S.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Y.set(this,i,r),t=o(this,i),this[i](),r!==(n=Y.get(this,i))||t?Y.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n&&n.value}else r.length&&(Y.set(this,i,{value:S.event.trigger(S.extend(r[0],S.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Y.get(e,i)&&S.event.add(e,i,we)}S.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.get(t);if(V(t)){n.handler&&(n=(o=n).handler,i=o.selector),i&&S.find.matchesSelector(re,i),n.guid||(n.guid=S.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof S&&S.event.triggered!==e.type?S.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(P)||[""]).length;while(l--)d=g=(s=be.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=S.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=S.event.special[d]||{},c=S.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&S.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),S.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.hasData(e)&&Y.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(P)||[""]).length;while(l--)if(d=g=(s=be.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=S.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||S.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)S.event.remove(e,d+t[l],n,r,!0);S.isEmptyObject(u)&&Y.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=S.event.fix(e),l=(Y.get(this,"events")||Object.create(null))[u.type]||[],c=S.event.special[u.type]||{};for(s[0]=u,t=1;t<arguments.length;t++)s[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){a=S.event.handlers.call(this,u,l),t=0;while((i=a[t++])&&!u.isPropagationStopped()){u.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!u.isImmediatePropagationStopped())u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((S.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,s))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<S(i,this).index(l):S.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(S.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[S.expando]?e:new S.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Se(t,"click",we),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Se(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Y.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},S.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},S.Event=function(e,t){if(!(this instanceof S.Event))return new S.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?we:Te,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&S.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[S.expando]=!0},S.Event.prototype={constructor:S.Event,isDefaultPrevented:Te,isPropagationStopped:Te,isImmediatePropagationStopped:Te,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=we,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=we,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=we,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},S.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:!0},S.event.addProp),S.each({focus:"focusin",blur:"focusout"},function(e,t){S.event.special[e]={setup:function(){return Se(this,e,Ce),!1},trigger:function(){return Se(this,e),!0},_default:function(){return!0},delegateType:t}}),S.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){S.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||S.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),S.fn.extend({on:function(e,t,n,r){return Ee(this,e,t,n,r)},one:function(e,t,n,r){return Ee(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,S(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Te),this.each(function(){S.event.remove(this,e,n,t)})}});var ke=/<script|<style|<link/i,Ae=/checked\s*(?:[^=]|=\s*.checked.)/i,Ne=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)S.event.add(t,i,s[i][n]);Q.hasData(e)&&(o=Q.access(e),a=S.extend({},o),Q.set(t,a))}}function He(n,r,i,o){r=g(r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&Ae.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),He(t,r,i,o)});if(f&&(t=(e=xe(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=S.map(ve(e,"script"),De)).length;c<f;c++)u=e,c!==p&&(u=S.clone(u,!0,!0),s&&S.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,S.map(a,qe),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Y.access(u,"globalEval")&&S.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?S._evalUrl&&!u.noModule&&S._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):b(u.textContent.replace(Ne,""),u,l))}return n}function Oe(e,t,n){for(var r,i=t?S.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||S.cleanData(ve(r)),r.parentNode&&(n&&ie(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}S.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=ie(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||S.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Le(o[r],a[r]);else Le(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=S.event.special,o=0;void 0!==(n=e[o]);o++)if(V(n)){if(t=n[Y.expando]){if(t.events)for(r in t.events)i[r]?S.event.remove(n,r):S.removeEvent(n,r,t.handle);n[Y.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),S.fn.extend({detach:function(e){return Oe(this,e,!0)},remove:function(e){return Oe(this,e)},text:function(e){return $(this,function(e){return void 0===e?S.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return He(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||je(this,e).appendChild(e)})},prepend:function(){return He(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=je(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return He(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return He(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(S.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return S.clone(this,e,t)})},html:function(e){return $(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!ke.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=S.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(S.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return He(this,arguments,function(e){var t=this.parentNode;S.inArray(this,n)<0&&(S.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),S.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){S.fn[e]=function(e){for(var t,n=[],r=S(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),S(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var Pe=new RegExp("^("+ee+")(?!px)[a-z%]+$","i"),Re=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},Me=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Ie=new RegExp(ne.join("|"),"i");function We(e,t,n){var r,i,o,a,s=e.style;return(n=n||Re(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||ie(e)||(a=S.style(e,t)),!y.pixelBoxStyles()&&Pe.test(a)&&Ie.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function Fe(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",re.appendChild(u).appendChild(l);var e=C.getComputedStyle(l);n="1%"!==e.top,s=12===t(e.marginLeft),l.style.right="60%",o=36===t(e.right),r=36===t(e.width),l.style.position="absolute",i=12===t(l.offsetWidth/3),re.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s,u=E.createElement("div"),l=E.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===l.style.backgroundClip,S.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),s},scrollboxSize:function(){return e(),i},reliableTrDimensions:function(){var e,t,n,r;return null==a&&(e=E.createElement("table"),t=E.createElement("tr"),n=E.createElement("div"),e.style.cssText="position:absolute;left:-11111px;border-collapse:separate",t.style.cssText="border:1px solid",t.style.height="1px",n.style.height="9px",n.style.display="block",re.appendChild(e).appendChild(t).appendChild(n),r=C.getComputedStyle(t),a=parseInt(r.height,10)+parseInt(r.borderTopWidth,10)+parseInt(r.borderBottomWidth,10)===t.offsetHeight,re.removeChild(e)),a}}))}();var Be=["Webkit","Moz","ms"],$e=E.createElement("div").style,_e={};function ze(e){var t=S.cssProps[e]||_e[e];return t||(e in $e?e:_e[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Be.length;while(n--)if((e=Be[n]+t)in $e)return e}(e)||e)}var Ue=/^(none|table(?!-c[ea]).+)/,Xe=/^--/,Ve={position:"absolute",visibility:"hidden",display:"block"},Ge={letterSpacing:"0",fontWeight:"400"};function Ye(e,t,n){var r=te.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function Qe(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=S.css(e,n+ne[a],!0,i)),r?("content"===n&&(u-=S.css(e,"padding"+ne[a],!0,i)),"margin"!==n&&(u-=S.css(e,"border"+ne[a]+"Width",!0,i))):(u+=S.css(e,"padding"+ne[a],!0,i),"padding"!==n?u+=S.css(e,"border"+ne[a]+"Width",!0,i):s+=S.css(e,"border"+ne[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function Je(e,t,n){var r=Re(e),i=(!y.boxSizingReliable()||n)&&"border-box"===S.css(e,"boxSizing",!1,r),o=i,a=We(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(Pe.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||!y.reliableTrDimensions()&&A(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===S.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===S.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+Qe(e,t,n||(i?"border":"content"),o,r,a)+"px"}function Ke(e,t,n,r,i){return new Ke.prototype.init(e,t,n,r,i)}S.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=We(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=X(t),u=Xe.test(t),l=e.style;if(u||(t=ze(s)),a=S.cssHooks[t]||S.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=te.exec(n))&&i[1]&&(n=se(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(S.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=X(t);return Xe.test(t)||(t=ze(s)),(a=S.cssHooks[t]||S.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=We(e,t,r)),"normal"===i&&t in Ge&&(i=Ge[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),S.each(["height","width"],function(e,u){S.cssHooks[u]={get:function(e,t,n){if(t)return!Ue.test(S.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?Je(e,u,n):Me(e,Ve,function(){return Je(e,u,n)})},set:function(e,t,n){var r,i=Re(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===S.css(e,"boxSizing",!1,i),s=n?Qe(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-Qe(e,u,"border",!1,i)-.5)),s&&(r=te.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=S.css(e,u)),Ye(0,t,s)}}}),S.cssHooks.marginLeft=Fe(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(We(e,"marginLeft"))||e.getBoundingClientRect().left-Me(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),S.each({margin:"",padding:"",border:"Width"},function(i,o){S.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+ne[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(S.cssHooks[i+o].set=Ye)}),S.fn.extend({css:function(e,t){return $(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Re(e),i=t.length;a<i;a++)o[t[a]]=S.css(e,t[a],!1,r);return o}return void 0!==n?S.style(e,t,n):S.css(e,t)},e,t,1<arguments.length)}}),((S.Tween=Ke).prototype={constructor:Ke,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||S.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(S.cssNumber[n]?"":"px")},cur:function(){var e=Ke.propHooks[this.prop];return e&&e.get?e.get(this):Ke.propHooks._default.get(this)},run:function(e){var t,n=Ke.propHooks[this.prop];return this.options.duration?this.pos=t=S.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):Ke.propHooks._default.set(this),this}}).init.prototype=Ke.prototype,(Ke.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=S.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){S.fx.step[e.prop]?S.fx.step[e.prop](e):1!==e.elem.nodeType||!S.cssHooks[e.prop]&&null==e.elem.style[ze(e.prop)]?e.elem[e.prop]=e.now:S.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=Ke.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},S.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},S.fx=Ke.prototype.init,S.fx.step={};var Ze,et,tt,nt,rt=/^(?:toggle|show|hide)$/,it=/queueHooks$/;function ot(){et&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(ot):C.setTimeout(ot,S.fx.interval),S.fx.tick())}function at(){return C.setTimeout(function(){Ze=void 0}),Ze=Date.now()}function st(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ne[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ut(e,t,n){for(var r,i=(lt.tweeners[t]||[]).concat(lt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function lt(o,e,t){var n,a,r=0,i=lt.prefilters.length,s=S.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=Ze||at(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:S.extend({},e),opts:S.extend(!0,{specialEasing:{},easing:S.easing._default},t),originalProperties:e,originalOptions:t,startTime:Ze||at(),duration:t.duration,tweens:[],createTween:function(e,t){var n=S.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=X(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=S.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=lt.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(S._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return S.map(c,ut,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),S.fx.timer(S.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}S.Animation=S.extend(lt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return se(n.elem,e,te.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(P);for(var n,r=0,i=e.length;r<i;r++)n=e[r],lt.tweeners[n]=lt.tweeners[n]||[],lt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ae(e),v=Y.get(e,"fxshow");for(r in n.queue||(null==(a=S._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,S.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],rt.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||S.style(e,r)}if((u=!S.isEmptyObject(t))||!S.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Y.get(e,"display")),"none"===(c=S.css(e,"display"))&&(l?c=l:(le([e],!0),l=e.style.display||l,c=S.css(e,"display"),le([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===S.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Y.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&le([e],!0),p.done(function(){for(r in g||le([e]),Y.remove(e,"fxshow"),d)S.style(e,r,d[r])})),u=ut(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?lt.prefilters.unshift(e):lt.prefilters.push(e)}}),S.speed=function(e,t,n){var r=e&&"object"==typeof e?S.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return S.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in S.fx.speeds?r.duration=S.fx.speeds[r.duration]:r.duration=S.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&S.dequeue(this,r.queue)},r},S.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ae).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=S.isEmptyObject(t),o=S.speed(e,n,r),a=function(){var e=lt(this,S.extend({},t),o);(i||Y.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=S.timers,r=Y.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&it.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||S.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Y.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=S.timers,o=n?n.length:0;for(t.finish=!0,S.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),S.each(["toggle","show","hide"],function(e,r){var i=S.fn[r];S.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(st(r,!0),e,t,n)}}),S.each({slideDown:st("show"),slideUp:st("hide"),slideToggle:st("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){S.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),S.timers=[],S.fx.tick=function(){var e,t=0,n=S.timers;for(Ze=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||S.fx.stop(),Ze=void 0},S.fx.timer=function(e){S.timers.push(e),S.fx.start()},S.fx.interval=13,S.fx.start=function(){et||(et=!0,ot())},S.fx.stop=function(){et=null},S.fx.speeds={slow:600,fast:200,_default:400},S.fn.delay=function(r,e){return r=S.fx&&S.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},tt=E.createElement("input"),nt=E.createElement("select").appendChild(E.createElement("option")),tt.type="checkbox",y.checkOn=""!==tt.value,y.optSelected=nt.selected,(tt=E.createElement("input")).value="t",tt.type="radio",y.radioValue="t"===tt.value;var ct,ft=S.expr.attrHandle;S.fn.extend({attr:function(e,t){return $(this,S.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){S.removeAttr(this,e)})}}),S.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?S.prop(e,t,n):(1===o&&S.isXMLDoc(e)||(i=S.attrHooks[t.toLowerCase()]||(S.expr.match.bool.test(t)?ct:void 0)),void 0!==n?null===n?void S.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=S.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(P);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),ct={set:function(e,t,n){return!1===t?S.removeAttr(e,n):e.setAttribute(n,n),n}},S.each(S.expr.match.bool.source.match(/\w+/g),function(e,t){var a=ft[t]||S.find.attr;ft[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=ft[o],ft[o]=r,r=null!=a(e,t,n)?o:null,ft[o]=i),r}});var pt=/^(?:input|select|textarea|button)$/i,dt=/^(?:a|area)$/i;function ht(e){return(e.match(P)||[]).join(" ")}function gt(e){return e.getAttribute&&e.getAttribute("class")||""}function vt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(P)||[]}S.fn.extend({prop:function(e,t){return $(this,S.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[S.propFix[e]||e]})}}),S.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&S.isXMLDoc(e)||(t=S.propFix[t]||t,i=S.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=S.find.attr(e,"tabindex");return t?parseInt(t,10):pt.test(e.nodeName)||dt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(S.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),S.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){S.propFix[this.toLowerCase()]=this}),S.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).addClass(t.call(this,e,gt(this)))});if((e=vt(t)).length)while(n=this[u++])if(i=gt(n),r=1===n.nodeType&&" "+ht(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=ht(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).removeClass(t.call(this,e,gt(this)))});if(!arguments.length)return this.attr("class","");if((e=vt(t)).length)while(n=this[u++])if(i=gt(n),r=1===n.nodeType&&" "+ht(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=ht(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){S(this).toggleClass(i.call(this,e,gt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=S(this),r=vt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=gt(this))&&Y.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Y.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+ht(gt(n))+" ").indexOf(t))return!0;return!1}});var yt=/\r/g;S.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,S(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=S.map(t,function(e){return null==e?"":e+""})),(r=S.valHooks[this.type]||S.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=S.valHooks[t.type]||S.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(yt,""):null==e?"":e:void 0}}),S.extend({valHooks:{option:{get:function(e){var t=S.find.attr(e,"value");return null!=t?t:ht(S.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=S(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=S.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<S.inArray(S.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),S.each(["radio","checkbox"],function(){S.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<S.inArray(S(e).val(),t)}},y.checkOn||(S.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var mt=/^(?:focusinfocus|focusoutblur)$/,xt=function(e){e.stopPropagation()};S.extend(S.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!mt.test(d+S.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[S.expando]?e:new S.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:S.makeArray(t,[e]),c=S.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,mt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Y.get(o,"events")||Object.create(null))[e.type]&&Y.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&V(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!V(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),S.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,xt),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,xt),S.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=S.extend(new S.Event,n,{type:e,isSimulated:!0});S.event.trigger(r,null,t)}}),S.fn.extend({trigger:function(e,t){return this.each(function(){S.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return S.event.trigger(e,t,n,!0)}}),y.focusin||S.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){S.event.simulate(r,e.target,S.event.fix(e))};S.event.special[r]={setup:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r);t||e.addEventListener(n,i,!0),Y.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r)-1;t?Y.access(e,r,t):(e.removeEventListener(n,i,!0),Y.remove(e,r))}}});var bt=C.location,wt={guid:Date.now()},Tt=/\?/;S.parseXML=function(e){var t,n;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){}return n=t&&t.getElementsByTagName("parsererror")[0],t&&!n||S.error("Invalid XML: "+(n?S.map(n.childNodes,function(e){return e.textContent}).join("\n"):e)),t};var Ct=/\[\]$/,Et=/\r?\n/g,St=/^(?:submit|button|image|reset|file)$/i,kt=/^(?:input|select|textarea|keygen)/i;function At(n,e,r,i){var t;if(Array.isArray(e))S.each(e,function(e,t){r||Ct.test(n)?i(n,t):At(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)At(n+"["+t+"]",e[t],r,i)}S.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!S.isPlainObject(e))S.each(e,function(){i(this.name,this.value)});else for(n in e)At(n,e[n],t,i);return r.join("&")},S.fn.extend({serialize:function(){return S.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=S.prop(this,"elements");return e?S.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!S(this).is(":disabled")&&kt.test(this.nodeName)&&!St.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=S(this).val();return null==n?null:Array.isArray(n)?S.map(n,function(e){return{name:t.name,value:e.replace(Et,"\r\n")}}):{name:t.name,value:n.replace(Et,"\r\n")}}).get()}});var Nt=/%20/g,jt=/#.*$/,Dt=/([?&])_=[^&]*/,qt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Lt=/^(?:GET|HEAD)$/,Ht=/^\/\//,Ot={},Pt={},Rt="*/".concat("*"),Mt=E.createElement("a");function It(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(P)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function Wt(t,i,o,a){var s={},u=t===Pt;function l(e){var r;return s[e]=!0,S.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function Ft(e,t){var n,r,i=S.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&S.extend(!0,e,r),e}Mt.href=bt.href,S.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:bt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(bt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Rt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":S.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Ft(Ft(e,S.ajaxSettings),t):Ft(S.ajaxSettings,e)},ajaxPrefilter:It(Ot),ajaxTransport:It(Pt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=S.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?S(y):S.event,x=S.Deferred(),b=S.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=qt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||bt.href)+"").replace(Ht,bt.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(P)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Mt.protocol+"//"+Mt.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=S.param(v.data,v.traditional)),Wt(Ot,v,t,T),h)return T;for(i in(g=S.event&&v.global)&&0==S.active++&&S.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Lt.test(v.type),f=v.url.replace(jt,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Nt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(Tt.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Dt,"$1"),o=(Tt.test(f)?"&":"?")+"_="+wt.guid+++o),v.url=f+o),v.ifModified&&(S.lastModified[f]&&T.setRequestHeader("If-Modified-Since",S.lastModified[f]),S.etag[f]&&T.setRequestHeader("If-None-Match",S.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+Rt+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=Wt(Pt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),!i&&-1<S.inArray("script",v.dataTypes)&&S.inArray("json",v.dataTypes)<0&&(v.converters["text script"]=function(){}),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(S.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(S.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--S.active||S.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return S.get(e,t,n,"json")},getScript:function(e,t){return S.get(e,void 0,t,"script")}}),S.each(["get","post"],function(e,i){S[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),S.ajax(S.extend({url:e,type:i,dataType:r,data:t,success:n},S.isPlainObject(e)&&e))}}),S.ajaxPrefilter(function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")}),S._evalUrl=function(e,t,n){return S.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){S.globalEval(e,t,n)}})},S.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=S(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){S(this).wrapInner(n.call(this,e))}):this.each(function(){var e=S(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){S(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){S(this).replaceWith(this.childNodes)}),this}}),S.expr.pseudos.hidden=function(e){return!S.expr.pseudos.visible(e)},S.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},S.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var Bt={0:200,1223:204},$t=S.ajaxSettings.xhr();y.cors=!!$t&&"withCredentials"in $t,y.ajax=$t=!!$t,S.ajaxTransport(function(i){var o,a;if(y.cors||$t&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Bt[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),S.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),S.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return S.globalEval(e),e}}}),S.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),S.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=S("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=ht(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&S.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?S("<div>").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}});var Xt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;S.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||S.guid++,i},S.holdReady=function(e){e?S.readyWait++:S.ready(!0)},S.isArray=Array.isArray,S.parseJSON=JSON.parse,S.nodeName=A,S.isFunction=m,S.isWindow=x,S.camelCase=X,S.type=w,S.now=Date.now,S.isNumeric=function(e){var t=S.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},S.trim=function(e){return null==e?"":(e+"").replace(Xt,"")},"function"==typeof define&&define.amd&&define("jquery",[],function(){return S});var Vt=C.jQuery,Gt=C.$;return S.noConflict=function(e){return C.$===S&&(C.$=Gt),e&&C.jQuery===S&&(C.jQuery=Vt),S},"undefined"==typeof e&&(C.jQuery=C.$=S),S});
/*!
 * jQuery UI Widget 1.13.2
 * http://jqueryui.com
 *
 * Copyright jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 */

//>>label: Widget
//>>group: Core
//>>description: Provides a factory for creating stateful widgets with a common API.
//>>docs: http://api.jqueryui.com/jQuery.widget/
//>>demos: http://jqueryui.com/widget/

( function( factory ) {
    if ( typeof define === "function" && define.amd ) {

        // AMD. Register as an anonymous module.
        define( [ "jquery" ], factory );
    } else {

        // Browser globals
        factory( jQuery );
    }
}( function( $ ) {
    "use strict";

    $.ui = $.ui || {};

    var version = $.ui.version = "1.13.2";

    var widgetUuid = 0;
    var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
    var widgetSlice = Array.prototype.slice;

    $.cleanData = ( function( orig ) {
        return function( elems ) {
            var events, elem, i;
            for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {

                // Only trigger remove when necessary to save time
                events = $._data( elem, "events" );
                if ( events && events.remove ) {
                    $( elem ).triggerHandler( "remove" );
                }
            }
            orig( elems );
        };
    } )( $.cleanData );

    $.widget = function( name, base, prototype ) {
        var existingConstructor, constructor, basePrototype;

        // ProxiedPrototype allows the provided prototype to remain unmodified
        // so that it can be used as a mixin for multiple widgets (#8876)
        var proxiedPrototype = {};

        var namespace = name.split( "." )[ 0 ];
        name = name.split( "." )[ 1 ];
        var fullName = namespace + "-" + name;

        if ( !prototype ) {
            prototype = base;
            base = $.Widget;
        }

        if ( Array.isArray( prototype ) ) {
            prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
        }

        // Create selector for plugin
        $.expr.pseudos[ fullName.toLowerCase() ] = function( elem ) {
            return !!$.data( elem, fullName );
        };

        $[ namespace ] = $[ namespace ] || {};
        existingConstructor = $[ namespace ][ name ];
        constructor = $[ namespace ][ name ] = function( options, element ) {

            // Allow instantiation without "new" keyword
            if ( !this || !this._createWidget ) {
                return new constructor( options, element );
            }

            // Allow instantiation without initializing for simple inheritance
            // must use "new" keyword (the code above always passes args)
            if ( arguments.length ) {
                this._createWidget( options, element );
            }
        };

        // Extend with the existing constructor to carry over any static properties
        $.extend( constructor, existingConstructor, {
            version: prototype.version,

            // Copy the object used to create the prototype in case we need to
            // redefine the widget later
            _proto: $.extend( {}, prototype ),

            // Track widgets that inherit from this widget in case this widget is
            // redefined after a widget inherits from it
            _childConstructors: []
        } );

        basePrototype = new base();

        // We need to make the options hash a property directly on the new instance
        // otherwise we'll modify the options hash on the prototype that we're
        // inheriting from
        basePrototype.options = $.widget.extend( {}, basePrototype.options );
        $.each( prototype, function( prop, value ) {
            if ( typeof value !== "function" ) {
                proxiedPrototype[ prop ] = value;
                return;
            }
            proxiedPrototype[ prop ] = ( function() {
                function _super() {
                    return base.prototype[ prop ].apply( this, arguments );
                }

                function _superApply( args ) {
                    return base.prototype[ prop ].apply( this, args );
                }

                return function() {
                    var __super = this._super;
                    var __superApply = this._superApply;
                    var returnValue;

                    this._super = _super;
                    this._superApply = _superApply;

                    returnValue = value.apply( this, arguments );

                    this._super = __super;
                    this._superApply = __superApply;

                    return returnValue;
                };
            } )();
        } );
        constructor.prototype = $.widget.extend( basePrototype, {

            // TODO: remove support for widgetEventPrefix
            // always use the name + a colon as the prefix, e.g., draggable:start
            // don't prefix for widgets that aren't DOM-based
            widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name
        }, proxiedPrototype, {
            constructor: constructor,
            namespace: namespace,
            widgetName: name,
            widgetFullName: fullName
        } );

        // If this widget is being redefined then we need to find all widgets that
        // are inheriting from it and redefine all of them so that they inherit from
        // the new version of this widget. We're essentially trying to replace one
        // level in the prototype chain.
        if ( existingConstructor ) {
            $.each( existingConstructor._childConstructors, function( i, child ) {
                var childPrototype = child.prototype;

                // Redefine the child widget using the same prototype that was
                // originally used, but inherit from the new version of the base
                $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
                    child._proto );
            } );

            // Remove the list of existing child constructors from the old constructor
            // so the old child constructors can be garbage collected
            delete existingConstructor._childConstructors;
        } else {
            base._childConstructors.push( constructor );
        }

        $.widget.bridge( name, constructor );

        return constructor;
    };

    $.widget.extend = function( target ) {
        var input = widgetSlice.call( arguments, 1 );
        var inputIndex = 0;
        var inputLength = input.length;
        var key;
        var value;

        for ( ; inputIndex < inputLength; inputIndex++ ) {
            for ( key in input[ inputIndex ] ) {
                value = input[ inputIndex ][ key ];
                if ( widgetHasOwnProperty.call( input[ inputIndex ], key ) && value !== undefined ) {

                    // Clone objects
                    if ( $.isPlainObject( value ) ) {
                        target[ key ] = $.isPlainObject( target[ key ] ) ?
                            $.widget.extend( {}, target[ key ], value ) :

                            // Don't extend strings, arrays, etc. with objects
                            $.widget.extend( {}, value );

                        // Copy everything else by reference
                    } else {
                        target[ key ] = value;
                    }
                }
            }
        }
        return target;
    };

    $.widget.bridge = function( name, object ) {
        var fullName = object.prototype.widgetFullName || name;
        $.fn[ name ] = function( options ) {
            var isMethodCall = typeof options === "string";
            var args = widgetSlice.call( arguments, 1 );
            var returnValue = this;

            if ( isMethodCall ) {

                // If this is an empty collection, we need to have the instance method
                // return undefined instead of the jQuery instance
                if ( !this.length && options === "instance" ) {
                    returnValue = undefined;
                } else {
                    this.each( function() {
                        var methodValue;
                        var instance = $.data( this, fullName );

                        if ( options === "instance" ) {
                            returnValue = instance;
                            return false;
                        }

                        if ( !instance ) {
                            return $.error( "cannot call methods on " + name +
                                " prior to initialization; " +
                                "attempted to call method '" + options + "'" );
                        }

                        if ( typeof instance[ options ] !== "function" ||
                            options.charAt( 0 ) === "_" ) {
                            return $.error( "no such method '" + options + "' for " + name +
                                " widget instance" );
                        }

                        methodValue = instance[ options ].apply( instance, args );

                        if ( methodValue !== instance && methodValue !== undefined ) {
                            returnValue = methodValue && methodValue.jquery ?
                                returnValue.pushStack( methodValue.get() ) :
                                methodValue;
                            return false;
                        }
                    } );
                }
            } else {

                // Allow multiple hashes to be passed on init
                if ( args.length ) {
                    options = $.widget.extend.apply( null, [ options ].concat( args ) );
                }

                this.each( function() {
                    var instance = $.data( this, fullName );
                    if ( instance ) {
                        instance.option( options || {} );
                        if ( instance._init ) {
                            instance._init();
                        }
                    } else {
                        $.data( this, fullName, new object( options, this ) );
                    }
                } );
            }

            return returnValue;
        };
    };

    $.Widget = function( /* options, element */ ) {};
    $.Widget._childConstructors = [];

    $.Widget.prototype = {
        widgetName: "widget",
        widgetEventPrefix: "",
        defaultElement: "<div>",

        options: {
            classes: {},
            disabled: false,

            // Callbacks
            create: null
        },

        _createWidget: function( options, element ) {
            element = $( element || this.defaultElement || this )[ 0 ];
            this.element = $( element );
            this.uuid = widgetUuid++;
            this.eventNamespace = "." + this.widgetName + this.uuid;

            this.bindings = $();
            this.hoverable = $();
            this.focusable = $();
            this.classesElementLookup = {};

            if ( element !== this ) {
                $.data( element, this.widgetFullName, this );
                this._on( true, this.element, {
                    remove: function( event ) {
                        if ( event.target === element ) {
                            this.destroy();
                        }
                    }
                } );
                this.document = $( element.style ?

                    // Element within the document
                    element.ownerDocument :

                    // Element is window or document
                    element.document || element );
                this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );
            }

            this.options = $.widget.extend( {},
                this.options,
                this._getCreateOptions(),
                options );

            this._create();

            if ( this.options.disabled ) {
                this._setOptionDisabled( this.options.disabled );
            }

            this._trigger( "create", null, this._getCreateEventData() );
            this._init();
        },

        _getCreateOptions: function() {
            return {};
        },

        _getCreateEventData: $.noop,

        _create: $.noop,

        _init: $.noop,

        destroy: function() {
            var that = this;

            this._destroy();
            $.each( this.classesElementLookup, function( key, value ) {
                that._removeClass( value, key );
            } );

            // We can probably remove the unbind calls in 2.0
            // all event bindings should go through this._on()
            this.element
                .off( this.eventNamespace )
                .removeData( this.widgetFullName );
            this.widget()
                .off( this.eventNamespace )
                .removeAttr( "aria-disabled" );

            // Clean up events and states
            this.bindings.off( this.eventNamespace );
        },

        _destroy: $.noop,

        widget: function() {
            return this.element;
        },

        option: function( key, value ) {
            var options = key;
            var parts;
            var curOption;
            var i;

            if ( arguments.length === 0 ) {

                // Don't return a reference to the internal hash
                return $.widget.extend( {}, this.options );
            }

            if ( typeof key === "string" ) {

                // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
                options = {};
                parts = key.split( "." );
                key = parts.shift();
                if ( parts.length ) {
                    curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
                    for ( i = 0; i < parts.length - 1; i++ ) {
                        curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
                        curOption = curOption[ parts[ i ] ];
                    }
                    key = parts.pop();
                    if ( arguments.length === 1 ) {
                        return curOption[ key ] === undefined ? null : curOption[ key ];
                    }
                    curOption[ key ] = value;
                } else {
                    if ( arguments.length === 1 ) {
                        return this.options[ key ] === undefined ? null : this.options[ key ];
                    }
                    options[ key ] = value;
                }
            }

            this._setOptions( options );

            return this;
        },

        _setOptions: function( options ) {
            var key;

            for ( key in options ) {
                this._setOption( key, options[ key ] );
            }

            return this;
        },

        _setOption: function( key, value ) {
            if ( key === "classes" ) {
                this._setOptionClasses( value );
            }

            this.options[ key ] = value;

            if ( key === "disabled" ) {
                this._setOptionDisabled( value );
            }

            return this;
        },

        _setOptionClasses: function( value ) {
            var classKey, elements, currentElements;

            for ( classKey in value ) {
                currentElements = this.classesElementLookup[ classKey ];
                if ( value[ classKey ] === this.options.classes[ classKey ] ||
                    !currentElements ||
                    !currentElements.length ) {
                    continue;
                }

                // We are doing this to create a new jQuery object because the _removeClass() call
                // on the next line is going to destroy the reference to the current elements being
                // tracked. We need to save a copy of this collection so that we can add the new classes
                // below.
                elements = $( currentElements.get() );
                this._removeClass( currentElements, classKey );

                // We don't use _addClass() here, because that uses this.options.classes
                // for generating the string of classes. We want to use the value passed in from
                // _setOption(), this is the new value of the classes option which was passed to
                // _setOption(). We pass this value directly to _classes().
                elements.addClass( this._classes( {
                    element: elements,
                    keys: classKey,
                    classes: value,
                    add: true
                } ) );
            }
        },

        _setOptionDisabled: function( value ) {
            this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );

            // If the widget is becoming disabled, then nothing is interactive
            if ( value ) {
                this._removeClass( this.hoverable, null, "ui-state-hover" );
                this._removeClass( this.focusable, null, "ui-state-focus" );
            }
        },

        enable: function() {
            return this._setOptions( { disabled: false } );
        },

        disable: function() {
            return this._setOptions( { disabled: true } );
        },

        _classes: function( options ) {
            var full = [];
            var that = this;

            options = $.extend( {
                element: this.element,
                classes: this.options.classes || {}
            }, options );

            function bindRemoveEvent() {
                var nodesToBind = [];

                options.element.each( function( _, element ) {
                    var isTracked = $.map( that.classesElementLookup, function( elements ) {
                        return elements;
                    } )
                        .some( function( elements ) {
                            return elements.is( element );
                        } );

                    if ( !isTracked ) {
                        nodesToBind.push( element );
                    }
                } );

                that._on( $( nodesToBind ), {
                    remove: "_untrackClassesElement"
                } );
            }

            function processClassString( classes, checkOption ) {
                var current, i;
                for ( i = 0; i < classes.length; i++ ) {
                    current = that.classesElementLookup[ classes[ i ] ] || $();
                    if ( options.add ) {
                        bindRemoveEvent();
                        current = $( $.uniqueSort( current.get().concat( options.element.get() ) ) );
                    } else {
                        current = $( current.not( options.element ).get() );
                    }
                    that.classesElementLookup[ classes[ i ] ] = current;
                    full.push( classes[ i ] );
                    if ( checkOption && options.classes[ classes[ i ] ] ) {
                        full.push( options.classes[ classes[ i ] ] );
                    }
                }
            }

            if ( options.keys ) {
                processClassString( options.keys.match( /\S+/g ) || [], true );
            }
            if ( options.extra ) {
                processClassString( options.extra.match( /\S+/g ) || [] );
            }

            return full.join( " " );
        },

        _untrackClassesElement: function( event ) {
            var that = this;
            $.each( that.classesElementLookup, function( key, value ) {
                if ( $.inArray( event.target, value ) !== -1 ) {
                    that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
                }
            } );

            this._off( $( event.target ) );
        },

        _removeClass: function( element, keys, extra ) {
            return this._toggleClass( element, keys, extra, false );
        },

        _addClass: function( element, keys, extra ) {
            return this._toggleClass( element, keys, extra, true );
        },

        _toggleClass: function( element, keys, extra, add ) {
            add = ( typeof add === "boolean" ) ? add : extra;
            var shift = ( typeof element === "string" || element === null ),
                options = {
                    extra: shift ? keys : extra,
                    keys: shift ? element : keys,
                    element: shift ? this.element : element,
                    add: add
                };
            options.element.toggleClass( this._classes( options ), add );
            return this;
        },

        _on: function( suppressDisabledCheck, element, handlers ) {
            var delegateElement;
            var instance = this;

            // No suppressDisabledCheck flag, shuffle arguments
            if ( typeof suppressDisabledCheck !== "boolean" ) {
                handlers = element;
                element = suppressDisabledCheck;
                suppressDisabledCheck = false;
            }

            // No element argument, shuffle and use this.element
            if ( !handlers ) {
                handlers = element;
                element = this.element;
                delegateElement = this.widget();
            } else {
                element = delegateElement = $( element );
                this.bindings = this.bindings.add( element );
            }

            $.each( handlers, function( event, handler ) {
                function handlerProxy() {

                    // Allow widgets to customize the disabled handling
                    // - disabled as an array instead of boolean
                    // - disabled class as method for disabling individual parts
                    if ( !suppressDisabledCheck &&
                        ( instance.options.disabled === true ||
                            $( this ).hasClass( "ui-state-disabled" ) ) ) {
                        return;
                    }
                    return ( typeof handler === "string" ? instance[ handler ] : handler )
                        .apply( instance, arguments );
                }

                // Copy the guid so direct unbinding works
                if ( typeof handler !== "string" ) {
                    handlerProxy.guid = handler.guid =
                        handler.guid || handlerProxy.guid || $.guid++;
                }

                var match = event.match( /^([\w:-]*)\s*(.*)$/ );
                var eventName = match[ 1 ] + instance.eventNamespace;
                var selector = match[ 2 ];

                if ( selector ) {
                    delegateElement.on( eventName, selector, handlerProxy );
                } else {
                    element.on( eventName, handlerProxy );
                }
            } );
        },

        _off: function( element, eventName ) {
            eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
                this.eventNamespace;
            element.off( eventName );

            // Clear the stack to avoid memory leaks (#10056)
            this.bindings = $( this.bindings.not( element ).get() );
            this.focusable = $( this.focusable.not( element ).get() );
            this.hoverable = $( this.hoverable.not( element ).get() );
        },

        _delay: function( handler, delay ) {
            function handlerProxy() {
                return ( typeof handler === "string" ? instance[ handler ] : handler )
                    .apply( instance, arguments );
            }
            var instance = this;
            return setTimeout( handlerProxy, delay || 0 );
        },

        _hoverable: function( element ) {
            this.hoverable = this.hoverable.add( element );
            this._on( element, {
                mouseenter: function( event ) {
                    this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
                },
                mouseleave: function( event ) {
                    this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
                }
            } );
        },

        _focusable: function( element ) {
            this.focusable = this.focusable.add( element );
            this._on( element, {
                focusin: function( event ) {
                    this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
                },
                focusout: function( event ) {
                    this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
                }
            } );
        },

        _trigger: function( type, event, data ) {
            var prop, orig;
            var callback = this.options[ type ];

            data = data || {};
            event = $.Event( event );
            event.type = ( type === this.widgetEventPrefix ?
                type :
                this.widgetEventPrefix + type ).toLowerCase();

            // The original event may come from any element
            // so we need to reset the target on the new event
            event.target = this.element[ 0 ];

            // Copy original event properties over to the new event
            orig = event.originalEvent;
            if ( orig ) {
                for ( prop in orig ) {
                    if ( !( prop in event ) ) {
                        event[ prop ] = orig[ prop ];
                    }
                }
            }

            this.element.trigger( event, data );
            return !( typeof callback === "function" &&
                callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||
                event.isDefaultPrevented() );
        }
    };

    $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
        $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
            if ( typeof options === "string" ) {
                options = { effect: options };
            }

            var hasOptions;
            var effectName = !options ?
                method :
                options === true || typeof options === "number" ?
                    defaultEffect :
                    options.effect || defaultEffect;

            options = options || {};
            if ( typeof options === "number" ) {
                options = { duration: options };
            } else if ( options === true ) {
                options = {};
            }

            hasOptions = !$.isEmptyObject( options );
            options.complete = callback;

            if ( options.delay ) {
                element.delay( options.delay );
            }

            if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
                element[ method ]( options );
            } else if ( effectName !== method && element[ effectName ] ) {
                element[ effectName ]( options.duration, options.easing, callback );
            } else {
                element.queue( function( next ) {
                    $( this )[ method ]();
                    if ( callback ) {
                        callback.call( element[ 0 ] );
                    }
                    next();
                } );
            }
        };
    } );

    var widget = $.widget;
}));
!function(n,r){"object"==typeof exports&&"undefined"!=typeof module?module.exports=r():"function"==typeof define&&define.amd?define("underscore",r):(n="undefined"!=typeof globalThis?globalThis:n||self,function(){var t=n._,e=n._=r();e.noConflict=function(){return n._=t,e}}())}(this,(function(){
//     Underscore.js 1.13.6
//     https://underscorejs.org
//     (c) 2009-2022 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors
//     Underscore may be freely distributed under the MIT license.
var n="1.13.6",r="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||Function("return this")()||{},t=Array.prototype,e=Object.prototype,u="undefined"!=typeof Symbol?Symbol.prototype:null,o=t.push,i=t.slice,a=e.toString,f=e.hasOwnProperty,c="undefined"!=typeof ArrayBuffer,l="undefined"!=typeof DataView,s=Array.isArray,p=Object.keys,v=Object.create,h=c&&ArrayBuffer.isView,y=isNaN,d=isFinite,g=!{toString:null}.propertyIsEnumerable("toString"),b=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"],m=Math.pow(2,53)-1;function j(n,r){return r=null==r?n.length-1:+r,function(){for(var t=Math.max(arguments.length-r,0),e=Array(t),u=0;u<t;u++)e[u]=arguments[u+r];switch(r){case 0:return n.call(this,e);case 1:return n.call(this,arguments[0],e);case 2:return n.call(this,arguments[0],arguments[1],e)}var o=Array(r+1);for(u=0;u<r;u++)o[u]=arguments[u];return o[r]=e,n.apply(this,o)}}function _(n){var r=typeof n;return"function"===r||"object"===r&&!!n}function w(n){return void 0===n}function A(n){return!0===n||!1===n||"[object Boolean]"===a.call(n)}function x(n){var r="[object "+n+"]";return function(n){return a.call(n)===r}}var S=x("String"),O=x("Number"),M=x("Date"),E=x("RegExp"),B=x("Error"),N=x("Symbol"),I=x("ArrayBuffer"),T=x("Function"),k=r.document&&r.document.childNodes;"function"!=typeof/./&&"object"!=typeof Int8Array&&"function"!=typeof k&&(T=function(n){return"function"==typeof n||!1});var D=T,R=x("Object"),F=l&&R(new DataView(new ArrayBuffer(8))),V="undefined"!=typeof Map&&R(new Map),P=x("DataView");var q=F?function(n){return null!=n&&D(n.getInt8)&&I(n.buffer)}:P,U=s||x("Array");function W(n,r){return null!=n&&f.call(n,r)}var z=x("Arguments");!function(){z(arguments)||(z=function(n){return W(n,"callee")})}();var L=z;function $(n){return O(n)&&y(n)}function C(n){return function(){return n}}function K(n){return function(r){var t=n(r);return"number"==typeof t&&t>=0&&t<=m}}function J(n){return function(r){return null==r?void 0:r[n]}}var G=J("byteLength"),H=K(G),Q=/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;var X=c?function(n){return h?h(n)&&!q(n):H(n)&&Q.test(a.call(n))}:C(!1),Y=J("length");function Z(n,r){r=function(n){for(var r={},t=n.length,e=0;e<t;++e)r[n[e]]=!0;return{contains:function(n){return!0===r[n]},push:function(t){return r[t]=!0,n.push(t)}}}(r);var t=b.length,u=n.constructor,o=D(u)&&u.prototype||e,i="constructor";for(W(n,i)&&!r.contains(i)&&r.push(i);t--;)(i=b[t])in n&&n[i]!==o[i]&&!r.contains(i)&&r.push(i)}function nn(n){if(!_(n))return[];if(p)return p(n);var r=[];for(var t in n)W(n,t)&&r.push(t);return g&&Z(n,r),r}function rn(n,r){var t=nn(r),e=t.length;if(null==n)return!e;for(var u=Object(n),o=0;o<e;o++){var i=t[o];if(r[i]!==u[i]||!(i in u))return!1}return!0}function tn(n){return n instanceof tn?n:this instanceof tn?void(this._wrapped=n):new tn(n)}function en(n){return new Uint8Array(n.buffer||n,n.byteOffset||0,G(n))}tn.VERSION=n,tn.prototype.value=function(){return this._wrapped},tn.prototype.valueOf=tn.prototype.toJSON=tn.prototype.value,tn.prototype.toString=function(){return String(this._wrapped)};var un="[object DataView]";function on(n,r,t,e){if(n===r)return 0!==n||1/n==1/r;if(null==n||null==r)return!1;if(n!=n)return r!=r;var o=typeof n;return("function"===o||"object"===o||"object"==typeof r)&&function n(r,t,e,o){r instanceof tn&&(r=r._wrapped);t instanceof tn&&(t=t._wrapped);var i=a.call(r);if(i!==a.call(t))return!1;if(F&&"[object Object]"==i&&q(r)){if(!q(t))return!1;i=un}switch(i){case"[object RegExp]":case"[object String]":return""+r==""+t;case"[object Number]":return+r!=+r?+t!=+t:0==+r?1/+r==1/t:+r==+t;case"[object Date]":case"[object Boolean]":return+r==+t;case"[object Symbol]":return u.valueOf.call(r)===u.valueOf.call(t);case"[object ArrayBuffer]":case un:return n(en(r),en(t),e,o)}var f="[object Array]"===i;if(!f&&X(r)){if(G(r)!==G(t))return!1;if(r.buffer===t.buffer&&r.byteOffset===t.byteOffset)return!0;f=!0}if(!f){if("object"!=typeof r||"object"!=typeof t)return!1;var c=r.constructor,l=t.constructor;if(c!==l&&!(D(c)&&c instanceof c&&D(l)&&l instanceof l)&&"constructor"in r&&"constructor"in t)return!1}o=o||[];var s=(e=e||[]).length;for(;s--;)if(e[s]===r)return o[s]===t;if(e.push(r),o.push(t),f){if((s=r.length)!==t.length)return!1;for(;s--;)if(!on(r[s],t[s],e,o))return!1}else{var p,v=nn(r);if(s=v.length,nn(t).length!==s)return!1;for(;s--;)if(p=v[s],!W(t,p)||!on(r[p],t[p],e,o))return!1}return e.pop(),o.pop(),!0}(n,r,t,e)}function an(n){if(!_(n))return[];var r=[];for(var t in n)r.push(t);return g&&Z(n,r),r}function fn(n){var r=Y(n);return function(t){if(null==t)return!1;var e=an(t);if(Y(e))return!1;for(var u=0;u<r;u++)if(!D(t[n[u]]))return!1;return n!==hn||!D(t[cn])}}var cn="forEach",ln="has",sn=["clear","delete"],pn=["get",ln,"set"],vn=sn.concat(cn,pn),hn=sn.concat(pn),yn=["add"].concat(sn,cn,ln),dn=V?fn(vn):x("Map"),gn=V?fn(hn):x("WeakMap"),bn=V?fn(yn):x("Set"),mn=x("WeakSet");function jn(n){for(var r=nn(n),t=r.length,e=Array(t),u=0;u<t;u++)e[u]=n[r[u]];return e}function _n(n){for(var r={},t=nn(n),e=0,u=t.length;e<u;e++)r[n[t[e]]]=t[e];return r}function wn(n){var r=[];for(var t in n)D(n[t])&&r.push(t);return r.sort()}function An(n,r){return function(t){var e=arguments.length;if(r&&(t=Object(t)),e<2||null==t)return t;for(var u=1;u<e;u++)for(var o=arguments[u],i=n(o),a=i.length,f=0;f<a;f++){var c=i[f];r&&void 0!==t[c]||(t[c]=o[c])}return t}}var xn=An(an),Sn=An(nn),On=An(an,!0);function Mn(n){if(!_(n))return{};if(v)return v(n);var r=function(){};r.prototype=n;var t=new r;return r.prototype=null,t}function En(n){return U(n)?n:[n]}function Bn(n){return tn.toPath(n)}function Nn(n,r){for(var t=r.length,e=0;e<t;e++){if(null==n)return;n=n[r[e]]}return t?n:void 0}function In(n,r,t){var e=Nn(n,Bn(r));return w(e)?t:e}function Tn(n){return n}function kn(n){return n=Sn({},n),function(r){return rn(r,n)}}function Dn(n){return n=Bn(n),function(r){return Nn(r,n)}}function Rn(n,r,t){if(void 0===r)return n;switch(null==t?3:t){case 1:return function(t){return n.call(r,t)};case 3:return function(t,e,u){return n.call(r,t,e,u)};case 4:return function(t,e,u,o){return n.call(r,t,e,u,o)}}return function(){return n.apply(r,arguments)}}function Fn(n,r,t){return null==n?Tn:D(n)?Rn(n,r,t):_(n)&&!U(n)?kn(n):Dn(n)}function Vn(n,r){return Fn(n,r,1/0)}function Pn(n,r,t){return tn.iteratee!==Vn?tn.iteratee(n,r):Fn(n,r,t)}function qn(){}function Un(n,r){return null==r&&(r=n,n=0),n+Math.floor(Math.random()*(r-n+1))}tn.toPath=En,tn.iteratee=Vn;var Wn=Date.now||function(){return(new Date).getTime()};function zn(n){var r=function(r){return n[r]},t="(?:"+nn(n).join("|")+")",e=RegExp(t),u=RegExp(t,"g");return function(n){return n=null==n?"":""+n,e.test(n)?n.replace(u,r):n}}var Ln={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;","`":"&#x60;"},$n=zn(Ln),Cn=zn(_n(Ln)),Kn=tn.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g},Jn=/(.)^/,Gn={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},Hn=/\\|'|\r|\n|\u2028|\u2029/g;function Qn(n){return"\\"+Gn[n]}var Xn=/^\s*(\w|\$)+\s*$/;var Yn=0;function Zn(n,r,t,e,u){if(!(e instanceof r))return n.apply(t,u);var o=Mn(n.prototype),i=n.apply(o,u);return _(i)?i:o}var nr=j((function(n,r){var t=nr.placeholder,e=function(){for(var u=0,o=r.length,i=Array(o),a=0;a<o;a++)i[a]=r[a]===t?arguments[u++]:r[a];for(;u<arguments.length;)i.push(arguments[u++]);return Zn(n,e,this,this,i)};return e}));nr.placeholder=tn;var rr=j((function(n,r,t){if(!D(n))throw new TypeError("Bind must be called on a function");var e=j((function(u){return Zn(n,e,r,this,t.concat(u))}));return e})),tr=K(Y);function er(n,r,t,e){if(e=e||[],r||0===r){if(r<=0)return e.concat(n)}else r=1/0;for(var u=e.length,o=0,i=Y(n);o<i;o++){var a=n[o];if(tr(a)&&(U(a)||L(a)))if(r>1)er(a,r-1,t,e),u=e.length;else for(var f=0,c=a.length;f<c;)e[u++]=a[f++];else t||(e[u++]=a)}return e}var ur=j((function(n,r){var t=(r=er(r,!1,!1)).length;if(t<1)throw new Error("bindAll must be passed function names");for(;t--;){var e=r[t];n[e]=rr(n[e],n)}return n}));var or=j((function(n,r,t){return setTimeout((function(){return n.apply(null,t)}),r)})),ir=nr(or,tn,1);function ar(n){return function(){return!n.apply(this,arguments)}}function fr(n,r){var t;return function(){return--n>0&&(t=r.apply(this,arguments)),n<=1&&(r=null),t}}var cr=nr(fr,2);function lr(n,r,t){r=Pn(r,t);for(var e,u=nn(n),o=0,i=u.length;o<i;o++)if(r(n[e=u[o]],e,n))return e}function sr(n){return function(r,t,e){t=Pn(t,e);for(var u=Y(r),o=n>0?0:u-1;o>=0&&o<u;o+=n)if(t(r[o],o,r))return o;return-1}}var pr=sr(1),vr=sr(-1);function hr(n,r,t,e){for(var u=(t=Pn(t,e,1))(r),o=0,i=Y(n);o<i;){var a=Math.floor((o+i)/2);t(n[a])<u?o=a+1:i=a}return o}function yr(n,r,t){return function(e,u,o){var a=0,f=Y(e);if("number"==typeof o)n>0?a=o>=0?o:Math.max(o+f,a):f=o>=0?Math.min(o+1,f):o+f+1;else if(t&&o&&f)return e[o=t(e,u)]===u?o:-1;if(u!=u)return(o=r(i.call(e,a,f),$))>=0?o+a:-1;for(o=n>0?a:f-1;o>=0&&o<f;o+=n)if(e[o]===u)return o;return-1}}var dr=yr(1,pr,hr),gr=yr(-1,vr);function br(n,r,t){var e=(tr(n)?pr:lr)(n,r,t);if(void 0!==e&&-1!==e)return n[e]}function mr(n,r,t){var e,u;if(r=Rn(r,t),tr(n))for(e=0,u=n.length;e<u;e++)r(n[e],e,n);else{var o=nn(n);for(e=0,u=o.length;e<u;e++)r(n[o[e]],o[e],n)}return n}function jr(n,r,t){r=Pn(r,t);for(var e=!tr(n)&&nn(n),u=(e||n).length,o=Array(u),i=0;i<u;i++){var a=e?e[i]:i;o[i]=r(n[a],a,n)}return o}function _r(n){var r=function(r,t,e,u){var o=!tr(r)&&nn(r),i=(o||r).length,a=n>0?0:i-1;for(u||(e=r[o?o[a]:a],a+=n);a>=0&&a<i;a+=n){var f=o?o[a]:a;e=t(e,r[f],f,r)}return e};return function(n,t,e,u){var o=arguments.length>=3;return r(n,Rn(t,u,4),e,o)}}var wr=_r(1),Ar=_r(-1);function xr(n,r,t){var e=[];return r=Pn(r,t),mr(n,(function(n,t,u){r(n,t,u)&&e.push(n)})),e}function Sr(n,r,t){r=Pn(r,t);for(var e=!tr(n)&&nn(n),u=(e||n).length,o=0;o<u;o++){var i=e?e[o]:o;if(!r(n[i],i,n))return!1}return!0}function Or(n,r,t){r=Pn(r,t);for(var e=!tr(n)&&nn(n),u=(e||n).length,o=0;o<u;o++){var i=e?e[o]:o;if(r(n[i],i,n))return!0}return!1}function Mr(n,r,t,e){return tr(n)||(n=jn(n)),("number"!=typeof t||e)&&(t=0),dr(n,r,t)>=0}var Er=j((function(n,r,t){var e,u;return D(r)?u=r:(r=Bn(r),e=r.slice(0,-1),r=r[r.length-1]),jr(n,(function(n){var o=u;if(!o){if(e&&e.length&&(n=Nn(n,e)),null==n)return;o=n[r]}return null==o?o:o.apply(n,t)}))}));function Br(n,r){return jr(n,Dn(r))}function Nr(n,r,t){var e,u,o=-1/0,i=-1/0;if(null==r||"number"==typeof r&&"object"!=typeof n[0]&&null!=n)for(var a=0,f=(n=tr(n)?n:jn(n)).length;a<f;a++)null!=(e=n[a])&&e>o&&(o=e);else r=Pn(r,t),mr(n,(function(n,t,e){((u=r(n,t,e))>i||u===-1/0&&o===-1/0)&&(o=n,i=u)}));return o}var Ir=/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;function Tr(n){return n?U(n)?i.call(n):S(n)?n.match(Ir):tr(n)?jr(n,Tn):jn(n):[]}function kr(n,r,t){if(null==r||t)return tr(n)||(n=jn(n)),n[Un(n.length-1)];var e=Tr(n),u=Y(e);r=Math.max(Math.min(r,u),0);for(var o=u-1,i=0;i<r;i++){var a=Un(i,o),f=e[i];e[i]=e[a],e[a]=f}return e.slice(0,r)}function Dr(n,r){return function(t,e,u){var o=r?[[],[]]:{};return e=Pn(e,u),mr(t,(function(r,u){var i=e(r,u,t);n(o,r,i)})),o}}var Rr=Dr((function(n,r,t){W(n,t)?n[t].push(r):n[t]=[r]})),Fr=Dr((function(n,r,t){n[t]=r})),Vr=Dr((function(n,r,t){W(n,t)?n[t]++:n[t]=1})),Pr=Dr((function(n,r,t){n[t?0:1].push(r)}),!0);function qr(n,r,t){return r in t}var Ur=j((function(n,r){var t={},e=r[0];if(null==n)return t;D(e)?(r.length>1&&(e=Rn(e,r[1])),r=an(n)):(e=qr,r=er(r,!1,!1),n=Object(n));for(var u=0,o=r.length;u<o;u++){var i=r[u],a=n[i];e(a,i,n)&&(t[i]=a)}return t})),Wr=j((function(n,r){var t,e=r[0];return D(e)?(e=ar(e),r.length>1&&(t=r[1])):(r=jr(er(r,!1,!1),String),e=function(n,t){return!Mr(r,t)}),Ur(n,e,t)}));function zr(n,r,t){return i.call(n,0,Math.max(0,n.length-(null==r||t?1:r)))}function Lr(n,r,t){return null==n||n.length<1?null==r||t?void 0:[]:null==r||t?n[0]:zr(n,n.length-r)}function $r(n,r,t){return i.call(n,null==r||t?1:r)}var Cr=j((function(n,r){return r=er(r,!0,!0),xr(n,(function(n){return!Mr(r,n)}))})),Kr=j((function(n,r){return Cr(n,r)}));function Jr(n,r,t,e){A(r)||(e=t,t=r,r=!1),null!=t&&(t=Pn(t,e));for(var u=[],o=[],i=0,a=Y(n);i<a;i++){var f=n[i],c=t?t(f,i,n):f;r&&!t?(i&&o===c||u.push(f),o=c):t?Mr(o,c)||(o.push(c),u.push(f)):Mr(u,f)||u.push(f)}return u}var Gr=j((function(n){return Jr(er(n,!0,!0))}));function Hr(n){for(var r=n&&Nr(n,Y).length||0,t=Array(r),e=0;e<r;e++)t[e]=Br(n,e);return t}var Qr=j(Hr);function Xr(n,r){return n._chain?tn(r).chain():r}function Yr(n){return mr(wn(n),(function(r){var t=tn[r]=n[r];tn.prototype[r]=function(){var n=[this._wrapped];return o.apply(n,arguments),Xr(this,t.apply(tn,n))}})),tn}mr(["pop","push","reverse","shift","sort","splice","unshift"],(function(n){var r=t[n];tn.prototype[n]=function(){var t=this._wrapped;return null!=t&&(r.apply(t,arguments),"shift"!==n&&"splice"!==n||0!==t.length||delete t[0]),Xr(this,t)}})),mr(["concat","join","slice"],(function(n){var r=t[n];tn.prototype[n]=function(){var n=this._wrapped;return null!=n&&(n=r.apply(n,arguments)),Xr(this,n)}}));var Zr=Yr({__proto__:null,VERSION:n,restArguments:j,isObject:_,isNull:function(n){return null===n},isUndefined:w,isBoolean:A,isElement:function(n){return!(!n||1!==n.nodeType)},isString:S,isNumber:O,isDate:M,isRegExp:E,isError:B,isSymbol:N,isArrayBuffer:I,isDataView:q,isArray:U,isFunction:D,isArguments:L,isFinite:function(n){return!N(n)&&d(n)&&!isNaN(parseFloat(n))},isNaN:$,isTypedArray:X,isEmpty:function(n){if(null==n)return!0;var r=Y(n);return"number"==typeof r&&(U(n)||S(n)||L(n))?0===r:0===Y(nn(n))},isMatch:rn,isEqual:function(n,r){return on(n,r)},isMap:dn,isWeakMap:gn,isSet:bn,isWeakSet:mn,keys:nn,allKeys:an,values:jn,pairs:function(n){for(var r=nn(n),t=r.length,e=Array(t),u=0;u<t;u++)e[u]=[r[u],n[r[u]]];return e},invert:_n,functions:wn,methods:wn,extend:xn,extendOwn:Sn,assign:Sn,defaults:On,create:function(n,r){var t=Mn(n);return r&&Sn(t,r),t},clone:function(n){return _(n)?U(n)?n.slice():xn({},n):n},tap:function(n,r){return r(n),n},get:In,has:function(n,r){for(var t=(r=Bn(r)).length,e=0;e<t;e++){var u=r[e];if(!W(n,u))return!1;n=n[u]}return!!t},mapObject:function(n,r,t){r=Pn(r,t);for(var e=nn(n),u=e.length,o={},i=0;i<u;i++){var a=e[i];o[a]=r(n[a],a,n)}return o},identity:Tn,constant:C,noop:qn,toPath:En,property:Dn,propertyOf:function(n){return null==n?qn:function(r){return In(n,r)}},matcher:kn,matches:kn,times:function(n,r,t){var e=Array(Math.max(0,n));r=Rn(r,t,1);for(var u=0;u<n;u++)e[u]=r(u);return e},random:Un,now:Wn,escape:$n,unescape:Cn,templateSettings:Kn,template:function(n,r,t){!r&&t&&(r=t),r=On({},r,tn.templateSettings);var e=RegExp([(r.escape||Jn).source,(r.interpolate||Jn).source,(r.evaluate||Jn).source].join("|")+"|$","g"),u=0,o="__p+='";n.replace(e,(function(r,t,e,i,a){return o+=n.slice(u,a).replace(Hn,Qn),u=a+r.length,t?o+="'+\n((__t=("+t+"))==null?'':_.escape(__t))+\n'":e?o+="'+\n((__t=("+e+"))==null?'':__t)+\n'":i&&(o+="';\n"+i+"\n__p+='"),r})),o+="';\n";var i,a=r.variable;if(a){if(!Xn.test(a))throw new Error("variable is not a bare identifier: "+a)}else o="with(obj||{}){\n"+o+"}\n",a="obj";o="var __t,__p='',__j=Array.prototype.join,"+"print=function(){__p+=__j.call(arguments,'');};\n"+o+"return __p;\n";try{i=new Function(a,"_",o)}catch(n){throw n.source=o,n}var f=function(n){return i.call(this,n,tn)};return f.source="function("+a+"){\n"+o+"}",f},result:function(n,r,t){var e=(r=Bn(r)).length;if(!e)return D(t)?t.call(n):t;for(var u=0;u<e;u++){var o=null==n?void 0:n[r[u]];void 0===o&&(o=t,u=e),n=D(o)?o.call(n):o}return n},uniqueId:function(n){var r=++Yn+"";return n?n+r:r},chain:function(n){var r=tn(n);return r._chain=!0,r},iteratee:Vn,partial:nr,bind:rr,bindAll:ur,memoize:function(n,r){var t=function(e){var u=t.cache,o=""+(r?r.apply(this,arguments):e);return W(u,o)||(u[o]=n.apply(this,arguments)),u[o]};return t.cache={},t},delay:or,defer:ir,throttle:function(n,r,t){var e,u,o,i,a=0;t||(t={});var f=function(){a=!1===t.leading?0:Wn(),e=null,i=n.apply(u,o),e||(u=o=null)},c=function(){var c=Wn();a||!1!==t.leading||(a=c);var l=r-(c-a);return u=this,o=arguments,l<=0||l>r?(e&&(clearTimeout(e),e=null),a=c,i=n.apply(u,o),e||(u=o=null)):e||!1===t.trailing||(e=setTimeout(f,l)),i};return c.cancel=function(){clearTimeout(e),a=0,e=u=o=null},c},debounce:function(n,r,t){var e,u,o,i,a,f=function(){var c=Wn()-u;r>c?e=setTimeout(f,r-c):(e=null,t||(i=n.apply(a,o)),e||(o=a=null))},c=j((function(c){return a=this,o=c,u=Wn(),e||(e=setTimeout(f,r),t&&(i=n.apply(a,o))),i}));return c.cancel=function(){clearTimeout(e),e=o=a=null},c},wrap:function(n,r){return nr(r,n)},negate:ar,compose:function(){var n=arguments,r=n.length-1;return function(){for(var t=r,e=n[r].apply(this,arguments);t--;)e=n[t].call(this,e);return e}},after:function(n,r){return function(){if(--n<1)return r.apply(this,arguments)}},before:fr,once:cr,findKey:lr,findIndex:pr,findLastIndex:vr,sortedIndex:hr,indexOf:dr,lastIndexOf:gr,find:br,detect:br,findWhere:function(n,r){return br(n,kn(r))},each:mr,forEach:mr,map:jr,collect:jr,reduce:wr,foldl:wr,inject:wr,reduceRight:Ar,foldr:Ar,filter:xr,select:xr,reject:function(n,r,t){return xr(n,ar(Pn(r)),t)},every:Sr,all:Sr,some:Or,any:Or,contains:Mr,includes:Mr,include:Mr,invoke:Er,pluck:Br,where:function(n,r){return xr(n,kn(r))},max:Nr,min:function(n,r,t){var e,u,o=1/0,i=1/0;if(null==r||"number"==typeof r&&"object"!=typeof n[0]&&null!=n)for(var a=0,f=(n=tr(n)?n:jn(n)).length;a<f;a++)null!=(e=n[a])&&e<o&&(o=e);else r=Pn(r,t),mr(n,(function(n,t,e){((u=r(n,t,e))<i||u===1/0&&o===1/0)&&(o=n,i=u)}));return o},shuffle:function(n){return kr(n,1/0)},sample:kr,sortBy:function(n,r,t){var e=0;return r=Pn(r,t),Br(jr(n,(function(n,t,u){return{value:n,index:e++,criteria:r(n,t,u)}})).sort((function(n,r){var t=n.criteria,e=r.criteria;if(t!==e){if(t>e||void 0===t)return 1;if(t<e||void 0===e)return-1}return n.index-r.index})),"value")},groupBy:Rr,indexBy:Fr,countBy:Vr,partition:Pr,toArray:Tr,size:function(n){return null==n?0:tr(n)?n.length:nn(n).length},pick:Ur,omit:Wr,first:Lr,head:Lr,take:Lr,initial:zr,last:function(n,r,t){return null==n||n.length<1?null==r||t?void 0:[]:null==r||t?n[n.length-1]:$r(n,Math.max(0,n.length-r))},rest:$r,tail:$r,drop:$r,compact:function(n){return xr(n,Boolean)},flatten:function(n,r){return er(n,r,!1)},without:Kr,uniq:Jr,unique:Jr,union:Gr,intersection:function(n){for(var r=[],t=arguments.length,e=0,u=Y(n);e<u;e++){var o=n[e];if(!Mr(r,o)){var i;for(i=1;i<t&&Mr(arguments[i],o);i++);i===t&&r.push(o)}}return r},difference:Cr,unzip:Hr,transpose:Hr,zip:Qr,object:function(n,r){for(var t={},e=0,u=Y(n);e<u;e++)r?t[n[e]]=r[e]:t[n[e][0]]=n[e][1];return t},range:function(n,r,t){null==r&&(r=n||0,n=0),t||(t=r<n?-1:1);for(var e=Math.max(Math.ceil((r-n)/t),0),u=Array(e),o=0;o<e;o++,n+=t)u[o]=n;return u},chunk:function(n,r){if(null==r||r<1)return[];for(var t=[],e=0,u=n.length;e<u;)t.push(i.call(n,e,e+=r));return t},mixin:Yr,default:tn});return Zr._=Zr,Zr}));
/**
 *    xbe4x is javascript implementation of the original ECMAScript for XML (E4X)
 *    Specification (ECMA-357) December 2005. This implementation is designed to emulate
 *    the implementation that is used in SpiderMonkey (Mozilla's JavaScript(TM) Engine)
 *    and therefore Firefox, Thunderbird, and most other Gecko based applications.
 *    Because the Mozilla implementation leaves out certain features of the
 *    specification, so does xbe4x. Please read the README file for a further
 *    explanation of these issues.
 *
 *
 *    @author Sam Shull <http://samshull.blogspot.com/>
 *    @version 0.1
 *
 *    @copyright Copyright (c) 2009 Sam Shull <http://samshull.blogspot.com/>
 *    @license <http://www.opensource.org/licenses/mit-license.html>
 *
 *    Permission is hereby granted, free of charge, to any person obtaining a copy
 *    of this software and associated documentation files (the "Software"), to deal
 *    in the Software without restriction, including without limitation the rights
 *    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *    copies of the Software, and to permit persons to whom the Software is
 *    furnished to do so, subject to the following conditions:
 *
 *    The above copyright notice and this permission notice shall be included in
 *    all copies or substantial portions of the Software.
 *
 *    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *    THE SOFTWARE.
 *
 *
 *    CHANGES:
 */

//this doesn't load if window.XML is already defined
if (!this.XML)
{
    (function ()
    {
        /*
         *
         *
         */
        var undefined, p,
            window                       = this,
            dns                          = [],
            defaultNamespace             = "",
            ELEMENT_NODE                 = 1,
            ATTRIBUTE_NODE               = 2,
            TEXT_NODE                    = 3,
            CDATA_SECTION_NODE           = 4,
            ENTITY_REFERENCE_NODE        = 5,
            ENTITY_NODE                  = 6,
            PROCESSING_INSTRUCTION_NODE  = 7,
            COMMENT_NODE                 = 8,
            DOCUMENT_NODE                = 9,
            DOCUMENT_TYPE_NODE           = 10,
            DOCUMENT_FRAGMENT_NODE       = 11,
            NOTATION_NODE                = 12,
            isNSDef                      = /^xmlns:([\w\-]+)/i,
            toString                     = ({}).toString,
            propertyIsEnumerable         = ({}).propertyIsEnumerable,
            hasOwnProperty               = ({}).hasOwnProperty,
            defaultXMLProperties         = ",prototype,ignoreComments,ignoreProcessingInstructions,ignoreWhitespace," +
                "prettyPrinting,prettyIndent,settings,defaultSettings,setSettings,settings," +
                "propertyIsEnumerable,hasOwnProperty,_setDefaultNamespace,",
            defaultXMLPrototype          = ",_Class,_Name,_Parent,_Value,_InScopeNamespaces,_Attributes,_Children,_Node",
            defaultXMLListPrototype      = ",_Class,_Value,_Children,_TargetObject,_TargetProperty",
            xmlDoc                       = parse("<x/>"),
            piName                       = /^[\w\-]+\s*/,
            XSLT_NS                      = "http://www.w3.org/1999/XSL/Transform";

        /**
         *
         *
         *    @param String | XML $string
         *    @returns XML
         *    @throws SyntaxError
         */
        function XML ($string)
        {
            if (!(this instanceof XML))
            {
                return ToXML($string);
            }

            var x, i, l;

            this._Class = "text";

            this._Name = null;

            this._Value = null;

            this._Parent = null;

            this._InScopeNamespaces = {};

            this._DefaultNamespace = null;

            this._Attributes = {};

            this._Children = [];

            this[0] = this;

            /**
             *
             *
             *
             */
            switch (typeof($string))
            {
                case "undefined":
                case "null":
                    break;
                case "number":
                case "boolean":    $string = ToString($string);
                case "string":

                    x = ToXML(trim($string));
                    if (x)
                    {
                        if (x.length() ===1)
                        {
                            this._Class = x._Class;
                            this._Name = x._Name;
                            this._Value = x._Value;
                            this._InScopeNamespaces = x._InScopeNamespaces;
                            this._DefaultNamespace = x._DefaultNamespace;
                            this._Attributes = x._Attributes;

                            for (i = 0, l = x._Children.length; i < l; ++i)
                            {
                                this._Children[i] = x._Children[i];
                                this._Children[i]._Parent = this;
                            }

                            break;
                        }
                    }

                    throw new SyntaxError();
                    break;
                default:
                    if ($string instanceof XML)
                    {
                        if ($string.length() ===1)
                        {
                            x = $string;
                            this._Class = x._Class;
                            this._Name = x._Name;
                            this._Value = x._Value;
                            this._InScopeNamespaces = x._InScopeNamespaces;
                            this._DefaultNamespace = x._DefaultNamespace;
                            this._Attributes = x._Attributes;

                            for (i = 0, l = x._Children.length; i < l; ++i)
                            {
                                this._Children[i] = x._Children[i];
                                this._Children[i]._Parent = this;
                            }
                        }
                    }
                    break;
            }
        }

        /**
         *    Ignore XML comments. (Default: true.)
         *
         *    @static
         *    @param Namespace ns
         *    @returns void
         */
        XML.setDefaultNamespace = function (ns)
        {
            dns.unshift(defaultNamespace || "");
            defaultNamespace = Namespace(ns);
            return null;
        };

        /**
         *  Use this function to restore the default namespace
         *  to the previous namespace
         *
         */
        XML.restoreDefaultNamespace = function ()
        {
            defaultNamespace = dns.shift() || "";
            return null;
        };

        /**
         *
         *
         *
         */
        XML.load = function (pathToFile, onload)
        {
            var xhr = isActiveXSupported("Microsoft.XMLHTTP") && new ActiveXObject("Microsoft.XMLHTTP") || new XMLHttpRequest(),
                async = ({}).toString.call(onload || {}) == "[object Function]";

            xhr.open("GET", pathToFile, async);

            if (async)
            {
                if (!!xhr.addEventListener)
                {
                    xhr.addEventListener("load", loaded, false);
                }
                else
                {
                    xhr.onreadystatechange = function ()
                    {
                        if (xhr.readyState == 4 && xhr.status == 200)
                        {
                            loaded();
                        }
                    };
                }
            }

            xhr.send(null);

            return async ? xhr : loaded(1);

            function loaded (ret)
            {
                var x = new XML((xhr.responseText||"").replace(/\s*<\?xml.*?\?>/,""));
                return ret ? x : onload(x);
            }
        };

        /**
         *    Ignore XML comments. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreComments = true;

        /**
         *    Ignore XML processing instructions. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreProcessingInstructions = true;

        /**
         *    Ignore whitespace. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreWhitespace = true;

        /**
         *    Pretty-print XML output with toXMLString() etc. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.prettyPrinting = true;

        /**
         *    Pretty indent level for child nodes. (Default: 2.)
         *
         *    @static
         *    @var Number
         */
        XML.prettyIndent = 2;

        //There are also three methods to more easily apply and restore settings for use, say, within a function.

        /**
         *    Get an Object containing the above settings.
         *
         *    @static
         *    @returns Object
         */
        XML.settings = function ()
        {
            return {
                ignoreComments:                 XML.ignoreComments,
                ignoreProcessingInstructions:   XML.ignoreProcessingInstructions,
                ignoreWhitespace:               XML.ignoreWhitespace,
                prettyPrinting:                 XML.prettyPrinting,
                prettyIndent:                   XML.prettyIndent
            };
        };

        /**
         *    Get an object containing the default settings.
         *
         *    @static
         *    @returns Object
         */
        XML.defaultSettings = function ()
        {
            return {
                ignoreComments:                 true,
                ignoreProcessingInstructions:   true,
                ignoreWhitespace:               true,
                prettyPrinting:                 true,
                prettyIndent:                   2
            };
        };

        /**
         *    Set XML settings from, e.g., an object returned by XML.settings().
         *
         *
         *    @static
         *    @param Object settings
         *    @returns void
         */
        XML.setSettings = function (settings)
        {
            var p;
            settings = settings || XML.settings();
            for (p in settings)
            {
                switch (p)
                {
                    case "ignoreComments":                   XML.ignoreComments = !!settings[p];
                    case "ignoreProcessingInstructions":     XML.ignoreProcessingInstructions = !!settings[p];
                    case "ignoreWhitespace":                 XML.ignoreWhitespace = !!settings[p];
                    case "prettyPrinting":                   XML.prettyPrinting = !!settings[p];
                    case "prettyIndent":                     XML.prettyIndent = parseInt(settings[p]) || 0;
                }
            }
            return null;
        };

        /**
         *
         *
         *    @static
         *    @param String name
         *    @returns Boolean
         */
        XML.hasOwnProperty = function (name)
        {
            return defaultXMLProperties.indexOf("," + name + ",") ===-1
                && hasOwnProperty.call(XML, name);
        };

        /**
         *
         *
         *    @static
         *    @param String name
         *    @returns Boolean
         */
        XML.propertyIsEnumerable = function (name)
        {
            return name !== "prototype"
                && name in XML
                && toString.call(XML[name]) != "[object Function]"
                && propertyIsEnumerable.call(XML, name);
        };

        /**
         *
         *
         *    @static
         *    @returns String
         */
        XML.toString = function ()
        {
            return "function XML() {\n [native code] \n}";
        };

        /**
         *
         *
         *    @param String | Namespace namespace
         *    @returns XML
         */
        XML.prototype.addNamespace = function (namespace)
        {
            AddInScopeNamespace.call(this, Namespace(namespace));
            return this;
        };

        /**
         *
         *
         *    @param String child
         *    @returns XML
         */
        XML.prototype.appendChild = function (child,isChildElement)
        {
            isChildElement = isChildElement !== undefined ? isChildElement : false;
            var children = Get.call(this, "*");
            children.Put(children.length(), child,isChildElement);
            return this;
        };

        /**
         *
         *
         *    @param String | AttributeName | QName attributeName
         *    @returns XML
         */
        XML.prototype.attribute = function (attributeName)
        {
            return Get.call(this, ToAttributeName(attributeName), true);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.attributes = function ()
        {
            return Get.call(this, ToAttributeName("*"));
        };

        /**
         *
         *
         *    @param String propertyName
         *    @returns XMLList
         */
        XML.prototype.child = function (propertyName)
        {
            var temporary;

            if (parseInt(propertyName)+"" == propertyName)
            {
                temporary = Get.call(this, "*");
                temporary = GetList.call(temporary, propertyName);
                return temporary || new XMLList();
            }

            temporary = ToXMLList( Get.call(this, propertyName) );

            return temporary;
        };

        /**
         *
         *
         *    @returns Number
         */
        XML.prototype.childIndex = function ()
        {
            var parent = this._Parent, q, l;

            if (!parent || this._Class === "attribute")
            {
                return -1;
            }

            for (q = 0, l = parent._Children.length; q < l; ++q)
            {
                if (parent._Children[q] === this)
                {
                    return q;
                }
            }

            return -1;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.children = function ()
        {
            return Get.call(this, "*");
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.comments = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "comment")
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns Boolean
         */
        XML.prototype.contains = function (value)
        {
            return this == value;
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.copy = function ()
        {
            return DeepCopy.call(this);
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XML.prototype.descendants = function (name)
        {
            return Descendants.call(this, name || "*");
        };

        /**
         *
         *
         *    @param String | QName | AttributeName name
         *    @returns XMLList
         */
        XML.prototype.elements = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = name;

            for (; i < l; ++i)
            {
                if (
                    this._Children[i]._Class === "element"
                        && (name.localName === "*" || name.localName === this._Children[i]._Name.localName)
                        && (name.uri == null || name.uri === this._Children[i]._Name.uri)
                    )
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XML.prototype.hasOwnProperty = function (name)
        {
            return HasProperty.call(this, name) || (defaultXMLPrototype.indexOf("," + name +",") === -1 && hasOwnProperty.call(this, name));
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XML.prototype.hasComplexContent = function ()
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XML.prototype.hasSimpleContent = function ()
        {
            if ((",comment,processing-instruction,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return false;
                }
            }

            return true;
        };

        /**
         *
         *
         *    @returns Array
         */
        XML.prototype.inScopeNamespaces = function ()
        {
            var y = this, inScopeNS = {}, p, a = [];

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!inScopeNS[p])
                    {
                        inScopeNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y.parent();
            }

            if (this._DefaultNamespace)
            {
                inScopeNS[""] = this._DefaultNamespace;
            }

            for (p in inScopeNS)
            {
                a[a.length] = inScopeNS[p];
            }

            return a;
        };

        /**
         *
         *
         *    @param XML child1
         *    @param XML child2
         *    @returns XML | null
         */
        XML.prototype.insertChildAfter = function (child1, child2)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            /*
             //this is disabled, because it doesn't work in
             //Firefox according to the spec
             if (!child2)
             {
             Insert.call(this, 0, child1);
             return this;
             }
             else if (!child1)
             {
             Insert.call(this, 0, child2);
             return this;
             }
             else
             */

            if (!child1){
                Insert.call(this, 0, child2);
                return this;
            }
            if (!child2){
                Insert.call(this, 0, child1);
                return this;
            }

            if (child1 instanceof XML)
            {
                Insert.call(this, child1.childIndex() + 1, child2);
                return this;
            }

            return null;
        };

        /**
         *
         *
         *
         *    @param XML child1
         *    @param XML child2
         *    @returns XML | null
         */
        XML.prototype.insertChildBefore = function (child1, child2)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            /*
             //this is disabled, because it doesn't work in
             //Firefox according to the spec
             if (!child1)
             {
             Insert.call(this, this._Children.length, child2);
             return this;
             }
             else if (!child2)
             {
             Insert.call(this, this._Children.length, child1);
             return this;
             }
             else
             */

            if (child1 instanceof XML)
            {
                Insert.call(this, child1.childIndex(), child2);
                return this;
            }

            return null;
        };

        /**
         *
         *
         *    @returns Number
         */
        XML.prototype.length = function ()
        {
            return 1;
        };

        /**
         *
         *
         *    @returns String | null
         */
        XML.prototype.localName = function ()
        {
            return this._Name === null ? null : this._Name.localName;
        };

        /**
         *
         *
         *    return QName
         */
        XML.prototype.name = function ()
        {
            return this._Name;
        };

        /**
         *
         *
         *    @param String prefix
         *    @returns Namespace
         */
        XML.prototype.namespace = function (prefix)
        {
            var y = this, inScopeNS = {}, p;

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!inScopeNS[p])
                    {
                        inScopeNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y.parent();
            }

            if (prefix === undefined)
            {
                if ((",comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
                {
                    return null;
                }

                return GetNamespace(this._Name, inScopeNS);
            }

            prefix = ToString(prefix);

            for (p in inScopeNS)
            {
                if (inScopeNS[p].prefix === prefix)
                {
                    return inScopeNS[p];
                }
            }

            return null;
        };

        /**
         *
         *
         *    @returns Array
         */
        XML.prototype.namespaceDeclarations = function ()
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return [];
            }

            var a = [], y = this._Parent, ancestorNS = {}, p;

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!ancestorNS[p])
                    {
                        ancestorNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y._Parent;
            }

            for (p in this._InScopeNamespaces)
            {
                if (p != "" && (!ancestorNS[p] || ancestorNS[p].uri != this._InScopeNamespaces[p]))
                {
                    a[a.length] = this._InScopeNamespaces[p];
                }
                else if(p === "" && !this._Parent)
                {
                    a[a.length] = this._InScopeNamespaces[p];
                }
            }

            return a;
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.nodeKind = function ()
        {
            return this._Class;
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.normalize = function ()
        {
            for (var i = 0, l = this._Children.length; i < l;)
            {
                if (this._Children[i]._Class === "element")
                {
                    this._Children[i].normalize();
                    ++i;
                }
                else if (this._Children[i]._Class === "text")
                {
                    while (i+1 < this._Children.length && this._Children[i+1]._Class === "text")
                    {
                        this._Children[i]._Value = (this._Children[i]._Value || "") + (this._Children[i+1]._Value || "");
                        DeleteByIndex.call(this, i+1);
                    }

                    if (this._Children[i]._Value.length === 0)
                    {
                        DeleteByIndex.call(this, i);
                    }
                    else
                    {
                        ++i;
                    }
                }
                else
                {
                    ++i;
                }
            }

            return this;
        };

        /**
         *
         *
         *    @returns XML | null
         */
        XML.prototype.parent = function ()
        {
            return this._Parent;
        };

        /**
         *
         *
         *    @param String name
         *    @returns XMLList
         */
        XML.prototype.processingInstructions = function (name)
        {
            name = ToXMLName(name || "*");

            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "processing-instruction"
                    && (name.localName === "*" || name.localName === this._Children[i]._Name.localName)
                    )
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.prependChild = function (value)
        {
            Insert.call(this, 0, value);
            return this;
        };


        XML.prototype.findFirstElement = function (value)
        {
            var list = [];
            list = this.elements(value)._Children;
            if(list.length == 0){
                var children = this.children();
                var xml;
                for(var i=0;i<children.length();i++){
                    xml = children[i];
                    var sublist = xml.findFirstElement(value);
                    if(sublist.length>0)
                        return sublist;
                }
            }
            return list;
        };


        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XML.prototype.propertyIsEnumerable = function (name)
        {
            return name == "0";
        };

        /**
         *
         *
         *    @param Namespace | String namespace
         *    @returns XML
         */
        XML.prototype.removeNamespace = function (namespace)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return this;
            }

            var ns = Namespace(namespace), thisNS = GetNamespace(this._Name, this._InScopeNamespaces), p, l;

            if (thisNS == ns)
            {
                return this;
            }

            /*
             //firefox does not remove the references to the
             //namespaces in attributes -- so we wont either
             for (p in this._Attributes)
             {
             if (GetNamespace(this._Attributes[p]._Name, this._InScopeNamespaces).uri == ns.uri)
             {
             this._Attributes[p]._Name = new QName(ns, this._Attributes[p].localName());
             }
             }
             //*/

            if (ns.prefix == undefined)
            {
                for (p in this._InScopeNamespaces)
                {
                    if (this._InScopeNamespaces[p].uri === ns.uri)
                    {
                        try{
                            this._InScopeNamespaces[p] = null;
                            delete this._InScopeNamespaces[p];
                        }catch(e){}
                    }
                }
            }
            else if (this._InScopeNamespaces[ns.prefix] && this._InScopeNamespaces[ns.prefix].uri === ns.uri)
            {
                try{
                    this._InScopeNamespaces[ns.prefix] = null;
                    delete this._InScopeNamespaces[ns.prefix];
                }catch(e){}
            }

            for (p = 0, l = this._Children.length; p < l; ++p)
            {
                if (this._Children[p]._Class === "element")
                {
                    this._Children[p].removeNamespace(ns);
                }
            }

            return this;
        };

        /**
         *
         *
         *    @param String propertyName
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.replace = function (propertyName, value)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return this;
            }

            var c = value instanceof XML ? DeepCopy.call(value) : ToString(value), n, i, k;

            if (parseInt(propertyName)+"" == propertyName)
            {
                Replace.call(this, propertyName, c);
                return this;
            }

            /*
             Basically Firefox does not appear to follow the rules set forth in the spec
             so, we are just going to fix this so that we do what firefox does
             if the propertyName is not an integer:
             if value is a XMLList setChildren
             otherwise do nothing
             */

            if (c instanceof XMLList)
            {
                this.setChildren(c);
            }

            return this;

            /*
             Leave the rest of these rules in place, just in case
             */

            n = QName(propertyName);
            k = this._Children.length;

            while (--k > -1)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName===n.localName))
                        && (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri ))
                    )
                {
                    if (i !== undefined)
                    {
                        DeleteByIndex.call(this, i);
                    }

                    i = k;
                }
            }

            if (i !== undefined)
            {
                Replace.call(this, i, c);
            }

            return this;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.setChildren = function (value)
        {
            this.Put("*", value);
            return this;
        };

        /**
         *
         *
         *    @param String name
         *    @returns void
         */
        XML.prototype.setLocalName = function (name)
        {
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._Name.localName = name instanceof QName ? name.localName : ToString(name);
        };

        /**
         *
         *
         *    @param QName | String name
         *    @returns null
         */
        XML.prototype.setName = function (name)
        {
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            if (name instanceof QName && name.uri == null)
            {
                name = name.localName;
            }

            var n = QName(name);

            if (this._Class === "processing-instruction")
            {
                n.uri = "";
            }

            this._DefaultNamespace = new Namespace(n.prefix, n.uri);

            this._Name = n;

            if (this._Class === "attribute")
            {
                if (this._Parent)
                {
                    AddInScopeNamespace.call(this._Parent, this._DefaultNamespace);
                }
            }
            else if (this._Class === "element")
            {
                AddInScopeNamespace.call(this, this._DefaultNamespace);
            }
            else if ((",comment,text,processing-instruction,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._Name = new QName(this._DefaultNamespace, this._Name.localName);

            return null;
        };

        /**
         *
         *
         *    @param Namespace | String ns
         *    @returns null
         */
        XML.prototype.setNamespace = function (ns)
        {
            //processing-instruction,
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._DefaultNamespace = Namespace(ns);

            this._Name = new QName(this._DefaultNamespace, this._Name.localName);

            if (this._Class === "attribute")
            {
                if (this._Parent)
                {
                    AddInScopeNamespace.call(this._Parent, this._DefaultNamespace);
                }
            }
            else if (this._Class === "element")
            {
                AddInScopeNamespace.call(this, this._DefaultNamespace);
            }

            return null;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.text = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "text")
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.toString = function ()
        {
            return ToString(this);
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.toXMLString = function ()
        {
            return ToXMLString(this);
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.valueOf = function ()
        {
            return this;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML | String Value
         *    @returns null
         *    @throws TypeError
         */
        XML.prototype.Put = function (PropertyName, Value)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                throw new TypeError();
            }

            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var c = (!(Value instanceof XML) || (",text,attribute,").indexOf("," + Value._Class+",") > -1)
                    ? ToString(Value)
                    : DeepCopy.call(Value),
                n = ToXMLName(PropertyName),
                s, i, l, a = null, primitiveAssign, k;

            if (n instanceof AttributeName)
            {
                if (!isXMLName(n._Name))
                {
                    return false;
                }

                if (c instanceof XMLList)
                {
                    if (c._Children.length === 0)
                    {
                        c = "";
                    }
                    else
                    {
                        s = ToString(c[0]);

                        for (i = 1, l = c._Children.length; i < l; ++i)
                        {
                            s += " " + ToString(c[i]);
                        }

                        c = s;
                    }
                }
                else
                {
                    c = ToString(c);
                }

                for (i in this._Attributes)
                {
                    if (
                        (n._Name.localName === this._Attributes[i]._Name.localName)
                            && (n._Name.uri === null || n._Name.uri === this._Attributes[i]._Name.uri)
                        )
                    {
                        if (a == null)
                        {
                            a = this._Attributes[i];
                        }
                        else
                        {
                            this.Delete(this._Attributes[i]._Name);
                        }
                    }
                }

                if (a == null)
                {
                    a = new XML();
                    a._Parent = this;
                    a._Class = "attribute";
                    a._Name = n._Name.uri == null
                        ? new QName(new Namespace(), n._Name)
                        : new QName(new Namespace(n._Name.uri), n._Name.localName);

                    this._Attributes[(a._Name._Prefix ? a._Name._Prefix + ":" : "") + a._Name.localName] = a;

                    AddInScopeNamespace.call(this, GetNamespace(a._Name));
                }

                a._Value = c;

                return null;
            }

            if (!isXMLName(n) && n.localName != "*")
            {
                return null;
            }

            i = undefined;

            primitiveAssign = !(c instanceof XML) && n.localName != "*";

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName===n.localName))
                        &&
                        (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                    )
                {
                    if (i != undefined)
                    {
                        DeleteByIndex.call(this, ToString(i));
                    }
                    else
                    {
                        i = k;
                    }
                }
            }

            if (i == undefined)
            {
                i = this._Children.length;

                if (primitiveAssign)
                {
                    a = new XML();
                    a._Class = "element";
                    a._Parent = this;
                    a._Name = n.uri == null
                        ? new QName(GetDefaultNamespace(), n)
                        : new QName(n);

                    Replace.call(this, ToString(i), a);

                    AddInScopeNamespace.call(a, GetNamespace(a._Name));
                }
            }

            if (primitiveAssign)
            {
                s = ToString(c);

                if (s != "")
                {
                    Replace.call(this._Children[i], "0", s);
                }
            }
            else
            {
                Replace.call(this, ToString(i), c);
            }

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns null
         *    @throws TypeError
         */
        XML.prototype.Delete = function (PropertyName)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                throw new TypeError();
            }

            var n = ToXMLName(PropertyName), k, dp = 0, q = 0, l;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName)
                            &&
                            (n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri)
                        )
                    {
                        this._Attributes[k]._Parent = null;
                        try{
                            delete this._Attributes[k];
                        }catch(e){}
                    }
                }

                return true;
            }

            for (l = this._Children.length; q < l; ++q)
            {
                if (
                    (n.localName === "*" || (this._Children[q]._Class === "element" && this._Children[q]._Name.localName === n.localName))
                        &&
                        (n.uri == null || (this._Children[q]._Class === "element" && n.uri === this._Children[q]._Name.uri))
                    )
                {
                    DeleteByIndex.call(this, q);
                    ++dp;
                }
                else if (dp > 0)
                {
                    this._Children[q - dp] = this._Children[q];
                }
            }


            return true;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns Boolean
         */
        XML.prototype.Equals = function (Value)
        {
            if (!(Value instanceof XML))
            {
                return false;
            }
            if (this._Class !== Value._Class)
            {
                return false;
            }
            if (this._Children.length !== Value._Children.length)
            {
                return false;
            }
            if (this._Value !== Value._Value)
            {
                return false;
            }
            if (this._Name !== null)
            {
                if (Value._Name === null)
                {
                    return false;
                }
                if (Value._Name.localName !== this._Name.localName)
                {
                    return false;
                }
                if (Value._Name.uri !== this._Name.uri)
                {
                    return false;
                }
            }
            else if (Value._Name !== null)
            {
                return false;
            }

            if (count(this._Attributes) !== count(Value._Attributes))
            {
                return false;
            }

            var a, b, k, l;

            for (k in this._Attributes)
            {
                a = this._Attributes[k];

                b = Value._Attributes[k];

                if (!b || b._Name.localName !== a._Name.localName || b._Name.uri !== a._Name.uri || b._Value !== a._Value)
                {
                    return false;
                }
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                a = this._Children[k];

                b = Value._Children[k];

                if (!arguments.callee.call(a, b))
                {
                    return false;
                }
            }

            return true;
        };

        //extensions

        /*
         * e4x.js
         *
         * A JavaScript library that implements the optional E4X features described in
         * ECMA-357 2nd Edition Annex A if they are not already implemented.
         *
         * 2010-03-13
         *
         * By Elijah Grey, http://eligrey.com
         * License: The X11/MIT license (see COPYING.md)
         *
         * Changes:
         *    By Sam Shull, http://samshull.blogspot.com
         *    Just a litlle simplifying for implementation
         */

        /*global document, XML, XMLList, DOMParser, XMLSerializer, XPathResult */

        /*jslint undef: true, nomen: true, eqeqeq: true, bitwise: true, regexp: true,
         newcap: true, immed: true, maxerr: 1000, maxlen: 90 */

        /**
         *
         *
         *
         */
        XML.prototype.domNode = function ()
        {
            return adoptNode(document, xmlToDomNode(this));
        };

        /**
         *
         *
         *
         */
        XML.prototype.domNodeList = function ()
        {
            if (this.length() < 0)
            {
                throw new Error();
            }

            return adoptNode(document, createDocumentFrom(this).documentElement).childNodes;
        };

        /**
         *
         *
         *
         */
        XML.prototype.xpath = function (xpathExp)
        {
            var res = new XMLList,
                i = 0, l = this.length(),
                xpr;

            if (l !== 1)
            {
                for (; i < l; ++i)
                {
                    res.Append(this[i].xpath(xpathExp));
                }

                return res;
            }

            xpr = evaluate(createDocumentFrom(this), xpathExp, this);

            for (l=xpr.length; i < l; ++i)
            {
                res.Append(ToXML(xpr[i]));
            }

            return res;
        };

        /**
         *
         *
         *
         */
        XML.prototype.transform = function (xslt, params)
        {
            if (!xslt instanceof XML)
            {
                throw new TypeError();
            }

            var doc, res, i, l = this.length(), c;

            if (l > 1)
            {
                res = new XMLList();
                for (i = 0; i < l; ++i)
                {
                    res.Append(this[i].transform(xslt, params));
                }
                return res;
            }

            return transform(this, xslt, params);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        function XMLList ($string)
        {
            if (!(this instanceof XMLList))
            {
                return ToXMLList($string || "");
            }

            this._Class = "XMLList";

            this._Value = undefined;


            this._TargetObject = null;

            this._TargetProperty = null;

            this._Children = [];

            this[0] = null;

            if ($string)
            {
                var list = ToXMLList($string), i = 0, l = list._Children.length;
                this._Value = list._Value;

                for (;i < l; ++i)
                {
                    this._Children[i] = this[i] = list._Children[i];
                }
            }
        }

        /**
         *
         *
         *    @static
         *    @returns String
         *    @throws TypeError
         */
        XMLList.toString = function ()
        {
            return "function XMLList() {\n [native code] \n}";
        };

        XMLList.prototype = new XML();

        var ignore = {xpath:1,domNodeList:1,transform:1};

        for (p in XMLList.prototype)
        {
            if (ignore[p])
            {
                continue;
            }

            XMLList.prototype[p] = (function(p)
            {
                return function ()
                {
                    if (this._Children.length != 1)
                    {
                        throw new TypeError("cannot call " + p + " method on an XML list with " + this._Children.length + " elements");
                    }

                    return XML.prototype[p].apply(this[0], arguments);
                };
            })(p);
        }

        try{
            delete XMLList.prototype._Attributes;
            delete XMLList.prototype._InScopeNamespaces;
        }catch(e){}

        /**
         *
         *
         *    @param String | AttributeName attributeName
         *    @returns XMLList
         */
        XMLList.prototype.attribute = function (attributeName)
        {
            return GetList.call(this, ToAttributeName(attributeName));
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.attributes = function ()
        {
            return GetList.call(this, ToAttributeName("*"));
        };

        /**
         *
         *
         *    @param String | QName propertyName
         *    @returns XMLList
         */
        XMLList.prototype.child = function (propertyName)
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                r = this[i].child(propertyName);

                if (r._Children.length > 0)
                {
                    list.Append(r);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.children = function ()
        {
            return GetList.call(this, "*");
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.comments = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].comments();

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns Boolean
         */
        XMLList.prototype.contains = function (value)
        {
            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this[i] == value)
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.copy = function ()
        {
            return DeepCopyList.call(this);
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.descendants = function (name)
        {
            return DescendantsList.call(this, name || "*");
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.elements = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;
            list._TargetProperty = name;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].elements(name);

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XMLList.prototype.hasOwnProperty = function (name)
        {
            return HasProperty.call(this, name)
                || (defaultXMLListProperties.indexOf("," + name + ",") === -1 && hasOwnProperty.call(this, name));
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XMLList.prototype.hasComplexContent = function ()
        {
            if (this._Children.length === 0)
            {
                return false;
            }

            if (this._Children.length === 1)
            {
                return this[0].hasComplexContent();
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XMLList.prototype.hasSimpleContent = function ()
        {
            if (this._Children.length === 1)
            {
                return this[0].hasSimpleContent();
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return false;
                }
            }

            return true;
        };

        /**
         *
         *
         *    @returns Number
         */
        XMLList.prototype.length = function ()
        {
            return this._Children.length;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.normalize = function ()
        {
            for (var i = 0, l = this._Children.length; i < l;)
            {
                if (this[i]._Class === "element")
                {
                    this[i].normalize();
                    ++i;
                }
                else if (this[i]._Class === "text")
                {
                    while (i+1 < this._Children.length && this[i+1]._Class === "text")
                    {
                        this[i]._Value = (this[i]._Value || "") + (this[i+1]._Value || "");
                        this.Delete(i+1);
                    }

                    if (this[i]._Value.length === 0)
                    {
                        this.Delete(i);
                    }
                    else
                    {
                        ++i;
                    }
                }
                else
                {
                    ++i;
                }
            }

            return this;
        };

        /**
         *
         *
         *    @returns XML | undefined
         */
        XMLList.prototype.parent = function ()
        {
            if (this._Children.length === 0)
            {
                return undefined;
            }

            for (var parent = this[0]._Parent, i = 1, l = this._Children.length; i < l; ++i)
            {
                if (this[i]._Parent != parent)
                {
                    return undefined;
                }
            }

            return parent;
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.processingInstructions = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].processingInstructions(name);

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String | Number name
         *    @returns Boolean
         */
        XMLList.prototype.propertyIsEnumerable = function (name)
        {
            return parseInt(name) > 0 && parseInt(name) < this._Children.length;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.text = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].text();

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns String
         */
        XMLList.prototype.toString = function ()
        {
            return ToString(this);
        };

        /**
         *
         *
         *    @returns String
         */
        XMLList.prototype.toXMLString = function ()
        {
            return ToXMLString(this);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.valueOf = function ()
        {
            return this;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @param XML Value
         *    @param isElement
         *    @returns null
         */
        XMLList.prototype.Put = function (PropertyName, Value,isChildElement)
        {
            isChildElement = isChildElement !== undefined ? isChildElement : false;
            var i = parseInt(PropertyName), r, y, l, z, parent, c, j = 0, q, t;

            if (i+"" == PropertyName)
            {
                r = ResolveValue.call(this._TargetObject);
                /* Firefox doesn't do this
                 if (r == null)
                 {
                 return null;
                 }
                 */
                if (i >= this._Children.length)
                {
                    if (r instanceof XMLList)
                    {
                        if (r.length() != 1)
                        {
                            return null;
                        }

                        r = r[0];
                    }

                    /* Firefox doesn't do this
                     if (r._Class != "element")
                     {
                     return null;
                     }
                     */
                    y = new XML();
                    y._Parent = r;
                    y._Name = this._TargetProperty;
                    y._Attributes = {};

                    if (this._TargetProperty instanceof AttributeName)
                    {
                        if (!!r && Get.call(r, y._Name).length() > 0)
                        {
                            return null;
                        }

                        y._Class = "attribute";
                    }
                    else if (!isChildElement && (this._TargetProperty == null || this._TargetProperty.localName === "*"))
                    {
                        y._Name = null;
                        y._Class = "text";
                    }
                    else
                    {
                        y._Class = "element";
                    }

                    if (y._Class != "attribute")
                    {
                        if (r)
                        {
                            j = 0;

                            if (i > 0)
                            {
                                while (j < r._Children.length-1 && r[j] !== this[i-1])
                                {
                                    ++j;
                                }
                            }
                            else
                            {
                                j = r._Children.length - 1;
                            }

                            Insert.call(r, j+1, y);
                        }

                        if (Value instanceof XMLList)
                        {
                            y._Name = Value._TargetProperty;
                        }
                        else if (Value instanceof XML)
                        {
                            y._Name = Value._Name;
                        }
                    }

                    this.Append(y);
                }

                if (!(Value instanceof XML) || Value._Class === "text" || Value._Class === "attribute")
                {
                    Value = ToString(Value);
                }

                if (this[i]._Class === "attribute")
                {
                    z = ToAttributeName(this[i]._Name);
                    this[i]._Parent.Put(z, Value);
                    this[i] = this[i]._Parent.attribute(z)[0];
                }
                else if (Value instanceof XMLList)
                {
                    //shallow copy?
                    c = Value;
                    parent = this[i]._Parent;

                    if (parent)
                    {
                        q = this[i].childIndex();
                        Replace.call(parent, q, c);
                        for (j = 0, l = c._Children.length; j < l; ++j)
                        {
                            c._Children[j] = c[j] = parent._Children[q+j];
                        }
                    }

                    if (c._Children.length === 0)
                    {
                        for (j = i + 1, l = this._Children.length; j < l; ++j)
                        {
                            this._Children[j-1] = this[j-1] = this[j]
                        }
                    }
                    else
                    {
                        for (j = this._Children.length; j > i; --j)
                        {
                            z = ToString(j + c._Children.length - 1);
                            this._Children[z] = this[z] = this[j];
                        }
                    }

                    for (j = 0, l = c._Children.length; j < l; ++j)
                    {
                        this._Children[i+j] = this[i+j] = c[j];
                    }

                }
                else if (Value instanceof XML || (",text,comment,processing-instruction").indexOf("," + this[i]._Class+",") > -1)
                {
                    parent = !!this[i] && this[i]._Parent;

                    if(parent)
                    {
                        q = this[i].childIndex();
                        Replace.call(parent, q, Value);
                        Value = parent._Children[q];
                    }

                    if (toString.call(Value) === "[object String]")
                    {
                        t = ToXML(Value);
                        t._Parent = this;
                        this._Children[i] = this[i] = t;
                    }
                    else
                    {

                    }
                }
                else
                {
                    this.Append(XMLList(Value));
                }
            }
            /* Firefox doesn't do this
             else if (this.length() <= 1)
             {
             if (this.length() === 0)
             {
             r = ResolveValueList.call(this);

             if (r == null || r.length() != 1)
             {
             return null;
             }

             this.Append(r);
             }
             else
             {
             this[0].Put(PropertyName, Value);
             }
             }*/

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @returns null
         */
        XMLList.prototype.Delete = function (PropertyName)
        {
            var i = parseInt(PropertyName), parent, q, l;

            if (i+"" == PropertyName)
            {
                if (i >= this._Children.length)
                {
                    return true;
                }

                parent = this[i]._Parent;

                if (parent)
                {
                    if (this[i]._Class = "attribute")
                    {
                        parent.Delete(ToAttributeName(this[i]._Name));
                    }
                    else
                    {
                        DeleteByIndex.call(parent, this[i].childIndex());
                    }
                }

                try{
                    this._Children.splice(PropertyName,1);
                    delete this[PropertyName];
                }catch(e){}

                for (q = i + 1, l = this._Children.length; q < l; ++q)
                {
                    this._Children[q-1] = this[q-1] = this[q];
                }
                return true;
            }
            /* Firefox won't do this
             for (q = 0, l = this._Children.length; q < l; ++q)
             {
             if (this[q]._Class === "element")
             {
             this[q].Delete(PropertyName);
             }
             }
             */
            return true;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns null
         */
        XMLList.prototype.Append = function (Value)
        {
            if (!(Value instanceof XML))
            {
                return null;
            }

            var i = this._Children.length, n = 1, j = 0;

            if (Value instanceof XMLList)
            {
                n = Value._Children.length;

                if (n == 0)
                {
                    return null;
                }

                this._TargetObject = Value._TargetObject;
                this._TargetProperty = Value._TargetProperty;

                for (;j < n; ++j)
                {
                    this._Children[i+j] = this[i+j] = Value[j];
                }
            }
            else
            {
                this._Children[i] = this[i] = Value;
            }

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns Boolean
         */
        XMLList.prototype.Equals = function (Value)
        {
            if (Value == undefined && this._Children.length === 0)
            {
                return true;
            }
            else if (Value instanceof XMLList && Value._Children.length === this._Children.length)
            {
                for (var i = 0, l = this._Children.length; i < l; ++i)
                {
                    if (!this[i].Equals(Value[i]))
                    {
                        return false;
                    }
                }
            }
            else if (this._Children.length === 1)
            {
                return this[0].Equals(Value);
            }

            return false;
        };

        /**
         *
         *
         *
         *    @access private
         *    @returns XMLList
         */
        function ResolveValueList ()
        {
            if (this._Children.length > 0)
            {
                return this;
            }

            if (this._TargetObject == null
                || this._TargetProperty == null
                || this._TargetProperty instanceof AttributeName
                || this._TargetProperty.localName === "*"
                )
            {
                return null;
            }

            var base = ResolveValue.call(this._TargetObject), target;

            if (base == null)
            {
                return null;
            }

            target = Get.call(base, this._TargetProperty);

            if (target._Children.length === 0)
            {
                if (base instanceof XMLList && base._Children.length > 1)
                {
                    return null;
                }

                base.Put(this._TargetProperty, "");

                target = Get.call(base, this._TargetProperty);
            }

            return target;
        };

        /**
         *
         *
         *    @param String | Namespace | QName prefix
         *    @param String uri
         *    @returns Namespace
         *    @throws TypeError
         */
        function Namespace (prefix, uri)
        {
            if (!(this instanceof Namespace))
            {
                return prefix && prefix instanceof Namespace
                    ? prefix
                    : new Namespace(prefix, uri);
            }

            if (uri === undefined && prefix === undefined)
            {
                this.prefix = "";
                this.uri = "";
            }
            else if (uri === undefined)
            {
                uri = prefix;
                prefix = undefined;

                if (uri instanceof Namespace)
                {
                    this.prefix = uri.prefix;
                    this.uri = uri.uri;
                }
                else if (uri instanceof QName && uri.uri !== null)
                {
                    this.uri = uri.uri;
                }
                else
                {
                    this.uri = ToString(uri);

                    if (this.uri == "")
                    {
                        this.prefix = "";
                    }
                }
            }
            else
            {
                if (uri instanceof QName)
                {
                    this.uri = uri.uri;
                }
                else
                {
                    this.uri = ToString(uri);
                }

                if (this.uri === "")
                {
                    if (prefix === undefined || ToString(prefix) === "")
                    {
                        this.prefix = "";
                    }
                    else
                    {
                        throw new TypeError("cannot define the prefix for an empty uri");
                    }
                }
                else if (prefix === undefined)
                {
                    this.prefix = undefined;
                }
                else
                {
                    this.prefix = ToString(prefix);
                }
            }
        }

        /**
         *
         *
         *    @var String
         */
        Namespace.prototype.prefix = undefined;

        /**
         *
         *
         *    @var String
         */
        Namespace.prototype.uri = undefined;

        /**
         *
         *
         *    @returns String
         */
        Namespace.prototype.toString = function ()
        {
            return this.uri;
        };

        /**
         *
         *
         *    @param Namespace | String | QName NameSpace
         *    @param String
         *    @returns QName
         */
        function QName (NameSpace, Name)
        {
            if (!(this instanceof QName))
            {
                return NameSpace instanceof QName
                    ? NameSpace
                    : new QName(NameSpace, Name);
            }

            if (Name === undefined)
            {
                Name = NameSpace;
                NameSpace = undefined;
            }

            if (Namespace instanceof QName)
            {
                if (Name === undefined)
                {
                    Name = Name.localName;
                }
            }

            Name = Name === undefined || Name === null
                ? ""
                : ToString(Name);

            if (NameSpace === undefined)
            {
                NameSpace = Name === "*" ? null : GetDefaultNamespace();
            }

            this.localName = Name;

            if (NameSpace == null)
            {
                this.uri = null;
            }
            else
            {
                NameSpace = Namespace(NameSpace);
                this.uri = NameSpace.uri;
                this._Prefix = NameSpace.prefix;
            }
        }

        /**
         *
         *
         *    @var String
         */
        QName.prototype.localName = undefined;

        /**
         *
         *
         *    @var String
         */
        QName.prototype.uri = undefined;

        /**
         *
         *
         *    @param Object InScopeNamespaces
         *    @returns Namespace
         *    @throws TypeError
         */
        function GetNamespace (q, InScopeNamespaces)
        {
            if(!q)
                 return new Namespace();
            if (q.uri === null)
            {
                throw new TypeError();
            }

            InScopeNamespaces = InScopeNamespaces || {};

            var ns, p;

            for (p in InScopeNamespaces)
            {
                if (q.uri === InScopeNamespaces[p].uri)
                {
                    ns = InScopeNamespaces[p];

                    if (!!q._Prefix && q._Prefix === ns.prefix)
                    {
                        return ns;
                    }
                }
            }

            if (!ns)
            {
                ns = !!q._Prefix
                    ? new Namespace(q._Prefix, q.uri)
                    : new Namespace(q.uri);
            }

            return ns;
        };

        /**
         *
         *
         *    @returns String
         */
        QName.prototype.toString = function ()
        {
            return !!this.uri
                ? this.uri + "::" + this.localName
                : this.localName;
        };

        /**
         *
         *
         *    @param AttributeName | QName | String name
         *    @returns AttributeName
         */
        function AttributeName (name)
        {
            if (!(this instanceof AttributeName))
            {
                return name && (name instanceof AttributeName || name instanceof QName)
                    ? name
                    : new AttributeName(name);
            }

            this._Name = name instanceof QName
                ? name
                : new QName(new Namespace(GetDefaultNamespace()||undefined), name);
        }

        /**
         *
         *
         *    @var String
         */
        AttributeName.prototype.localName = undefined;

        /**
         *
         *
         *    @var String
         */
        AttributeName.prototype.uri = undefined;

        /**
         *
         *
         *    @returns String
         */
        AttributeName.prototype.toString = function ()
        {
            return "@" + (!!this._Name.uri
                ? this._Name.uri + "::" + this._Name.localName
                : this._Name.localName
                );
        };

        /**
         *
         *
         *
         */
        function AnyName ()
        {

        }

        /**
         *
         *
         *    @param mixed value
         *    @returns Boolean
         */
        function isXMLName (value)
        {
            if (value instanceof AttributeName)
            {
                return true;
            }

            try{
                var q = QName(value);
            }
            catch (e)
            {
                return false;
            }

            return !!q.localName && (!!q.localName.match(/^[\w\-]+$/i) || !!q.localName.match(/^[\w\-\:]+$/i));
        }

        /**
         *
         *
         *    @param mixed value
         *    @returns String
         *    @throws TypeError
         */
        function ToString (value)
        {
            var i = 0, l, s;

            if (value instanceof XMLList)
            {
                if (value.hasSimpleContent())
                {
                    s = "";

                    for (l = value.length(); i < l; ++i)
                    {
                        if (value[i]._Class != "comment" && value[i]._Class != "processing-instruction")
                        {
                            s += ToString(value[i]);
                        }
                    }

                    return s;
                }

                return ToXMLString(value);
            }
            else if (value instanceof XML)
            {
                if (value._Class === "attribute" || value._Class === "text")
                {
                    return value._Value;
                }

                if (value.hasSimpleContent())
                {
                    s = "";

                    for (l = value.length(); i < l; ++i)
                    {
                        if (value.child(i)._Class != "comment" && value.child(i)._Class != "processing-instruction")
                        {
                            s += ToString(value.child(i));
                        }
                    }

                    return s;
                }

                return ToXMLString(value);
            }
            else if (value instanceof AttributeName)
            {
                return "@" + ToString(value._Name);
            }

            return value === null || value === undefined
                ? ""
                : "" + value;
        }

        /**
         *
         *
         *    @param XML input
         *    @param Object AncestorNamespaces
         *    @param Number IndentLevel
         *    @returns String
         */
        function ToXMLString (input, AncestorNamespaces, IndentLevel)
        {
            var s = "", p = 0, temp, temp2, namespace, namespaceUnion,
                namespaceDeclarations = {}, attrAndNamespaces, prefixes, defaultSet;

            AncestorNamespaces = AncestorNamespaces || {};

            IndentLevel = Number(IndentLevel || 0);

            if (input instanceof XMLList)
            {
                temp = input.hasSimpleContent();

                temp2 = input.length();

                for (; p < temp2; ++p)
                {
                    if (p > 0)
                    {
                        s += "\r\n";
                    }

                    s += ToXMLString(input[p], AncestorNamespaces);
                }

                return s;
            }
            else if (input instanceof XML)
            {
                if (XML.prettyPrinting)
                {
                    //s += new Array(IndentLevel+1).join(" ");
                    for (; p < IndentLevel; ++p)
                    {
                        s += " ";
                    }
                }

                switch (input._Class)
                {
                    case "text":
                        return s + EscapeElementValue(XML.prettyPrinting ? trim(input._Value) : input._Value);

                    case "attribute":
                        return s + EscapeAttributeValue(input._Value);

                    case "comment":
                        return s + "<!--" + input._Value + "-->";

                    case "processing-instruction":
                        return s + "<?" + input._Name.localName + " " + input._Value + "?>";

                    default:
                        namespaceUnion = extend({}, AncestorNamespaces);

                        for (p in input._InScopeNamespaces)
                        {
                            temp = input._InScopeNamespaces[p];

                            if (!AncestorNamespaces[(temp.prefix||"")] || AncestorNamespaces[(temp.prefix||"")].uri != temp.uri)
                            {
                                namespaceUnion[(temp.prefix||"")] = namespaceDeclarations[(temp.prefix||"")] = new Namespace(temp);
                            }
                        }

                        if (!input._Parent)
                        {
                            namespaceUnion[(input._DefaultNamespace.prefix||"")] =
                                namespaceDeclarations[(input._DefaultNamespace.prefix||"")] = new Namespace(input._DefaultNamespace);
                        }
                        /*
                         //firefox doesn't do this
                         for (p in input._Attributes)
                         {
                         namespace = GetNamespace(input._Attributes[p]._Name, namespaceUnion);

                         if (namespace.prefix === undefined)
                         {
                         do {
                         namespace.prefix = !namespaceUnion[""] ? "" : newPrefix();
                         }
                         while(!!namespaceUnion[namespace.prefix]);
                         }

                         namespaceUnion[namespace.prefix] = namespaceDeclarations[namespace.prefix] = namespace;
                         }
                         */

                        s += "<";

                        namespace = GetNamespace(input._Name, namespaceDeclarations);

                        if (namespace.prefix)
                        {
                            s += namespace.prefix + ":";
                        }

                        s += input._Name ? input._Name.localName : "";

                        attrAndNamespaces = extend({}, input._Attributes, namespaceDeclarations);

                        defaultSet = false;

                        for (p in attrAndNamespaces)
                        {
                            s += " ";

                            if (attrAndNamespaces[p] instanceof XML)
                            {
                                temp = GetNamespace(attrAndNamespaces[p]._Name, AncestorNamespaces);

                                if (temp.prefix === undefined && !namespaceUnion[""])
                                {
                                    do{
                                        temp.prefix = !namespaceUnion[""] ? "" : newPrefix();
                                    }
                                    while(namespaceUnion[temp.prefix]);

                                    namespaceUnion[temp.prefix] = namespaceDeclarations[temp.prefix] = new Namespace(temp);
                                }

                                if (temp.prefix)
                                {
                                    s += temp.prefix + ":";
                                }

                                s += attrAndNamespaces[p].localName() + '="' + EscapeAttributeValue(attrAndNamespaces[p]._Value) + '"';
                            }
                            else
                            {
                                s += "xmlns";

                                if (!attrAndNamespaces[p].prefix && defaultSet)
                                {
                                    do{
                                        attrAndNamespaces[p].prefix = newPrefix();
                                    }
                                    while(!!namespaceUnion[attrAndNamespaces[p].prefix]);

                                    namespaceUnion[attrAndNamespaces[p].prefix] =
                                        namespaceDeclarations[attrAndNamespaces[p].prefix] =
                                            new Namespace(attrAndNamespaces[p]);

                                    s += ":" + attrAndNamespaces[p].prefix;
                                }
                                else if (!attrAndNamespaces[p].prefix && !defaultSet)
                                {
                                    defaultSet = true;
                                }
                                else if (attrAndNamespaces[p].prefix)
                                {
                                    s += ":" + attrAndNamespaces[p].prefix;
                                }

                                s += '="' + EscapeAttributeValue(attrAndNamespaces[p].uri) + '"';
                            }
                        }

                        temp = input._Children.length;

                        if (!temp)
                        {
                            return s + "/>";
                        }

                        s += ">";

                        temp2 = temp > 1 || (temp == 1 && input._Class !== "text");

                        names = (!!XML.prettyPrinting && !!temp2) ? IndentLevel + Number(XML.prettyIndent) : 0;

                        prefixes = !!XML.prettyPrinting && !!temp2;

                        for (p = 0; p < temp; ++p)
                        {
                            if (prefixes)
                            {
                                s += "\r\n";
                            }

                            if (input._Children[p])
                            {
                                s += ToXMLString(input._Children[p], namespaceDeclarations, names);
                            }
                        }

                        if (prefixes)
                        {
                            s += "\r\n";

                            for (p = 0; p < IndentLevel; ++p)
                            {
                                s += " ";
                            }
                        }

                        return s + "</" + (namespace.prefix ? namespace.prefix + ":" : "") + input._Name.localName + ">";
                }

                throw new TypeError();
            }
            else if (input === undefined || input === null)
            {
                throw new TypeError();
            }
            else if (toString.call(input) === "[object Object]")
            {
                return EscapeElementValue( input.valueOf().toString() );
            }

            return ToString(input);
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XML
         *    @throws SyntaxError | TypeError
         */
        function ToXML (s)
        {
            var x, div;

            if (s instanceof XMLList)
            {
                if (s.length() == 1)
                {
                    return s[0];
                }
            }
            else if (s instanceof XML)
            {
                return s;
            }
            else if ((",string,number,boolean,").indexOf("," + typeof(s)+",") > -1)
            {

                div = parse('<parent xmlns="' + GetDefaultNamespace() + '">' + s + '</parent>');

                x = ToXML(div.documentElement)

                if (x)
                {
                    if (x.length() == 0)
                    {
                        return new XML();
                    }
                    else if (x.length() == 1)
                    {
                        x.child(0)._Parent = null;
                        return x.child(0);
                    }
                }


                throw new SyntaxError("Failed to convert DOM object to XML");
            }
            else if (s.nodeType && !isNaN(s.nodeType))
            {
                return MapInfoItemToXML(s);
            }

            throw new TypeError();
        }

        /**
         *
         *
         *    @param DOMNode i
         *    @returns XML
         *    @throws TypeError
         */
        function MapInfoItemToXML (i,n)
        {
            var x = new XML(), temp, temp2, temp3, isNScheck = isNSDef, j, l, xmlChild;

            x._Parent = null;

            switch (i.nodeType)
            {
                case TEXT_NODE:
                case CDATA_SECTION_NODE:
                    x._Class = "text";
                    x._Value = "";
                    temp = i;

                    while (temp && (temp.nodeType === TEXT_NODE || temp.nodeType === CDATA_SECTION_NODE))
                    {
                        x._Value += temp.textContent || temp.text || temp.data;
                        temp = temp.nextSibling;
                        if (n && (n.n || n.n == 0))
                        {
                            ++n.n;
                        }
                    }


                    if (XML.ignoreWhitespace && !x._Value.match(/\S+/))
                    {
                        return null;
                    }

                    return x;

                    break;
                case COMMENT_NODE:
                    if (XML.ignoreComments)
                    {
                        return null;
                    }

                    x._Class = "comment";
                    x._Value = i.data || i.textContent || i.text || "";

                    return x;

                    break;
                case PROCESSING_INSTRUCTION_NODE:
                    if (XML.ignoreProcessingInstructions)
                    {
                        return null;
                    }

                    x._Class = "processing-instruction";
                    x._Name = new QName("", i.target);
                    x._Value = i.data || i.textContent || i.text || "";

                    return x;

                    break;
                case ATTRIBUTE_NODE:
                    x._Class = "attribute";

                    temp = i.nodeName.match(/(([\w\-]+):)?([\w\-]+)/);

                    if ( temp[1] )
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace(temp[2]);
                        }
                        else
                        {
                            temp3 = n;//hack for ie -- stupid ie

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == ("xmlns:" + temp[2]))
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }
                        x._DefaultNamespace = new Namespace( temp[2], temp2 );
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }
                    else
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace("");
                        }
                        else
                        {
                            temp3 = i.parentNode;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == "xmlns")
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }

                        x._DefaultNamespace = new Namespace("", temp2);
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }

                    x._Value = i.value || null;

                    return x;

                    break;
                case ELEMENT_NODE:
                    x._Class = "element";
                    temp = i.nodeName.match(/(([\w\-]+):)?([\w\-]+)/);

                    if ( temp[1] )
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace(temp[2]);
                        }
                        else
                        {
                            temp3 = i;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == ("xmlns:" + temp[2]))
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }
                        x._DefaultNamespace = new Namespace( temp[2], temp2 );
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }
                    else
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace("");
                        }
                        else
                        {
                            temp3 = i;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == "xmlns")
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }

                        x._DefaultNamespace = new Namespace("", temp2);

                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }

                    for (temp = 0, temp2 = i.attributes.length; temp < temp2; ++temp)
                    {
                        if (temp3 = isNScheck.exec(i.attributes[temp].nodeName))
                        {
                            x._InScopeNamespaces[temp3[1]] = new Namespace(temp3[1], i.attributes[temp].value);
                        }
                        else if (i.attributes[temp].nodeName === "xmlns")
                        {
                            x._InScopeNamespaces[""] = new Namespace(i.attributes[temp].value);
                        }
                        else
                        {
                            x._Attributes[i.attributes[temp].nodeName] = MapInfoItemToXML(i.attributes[temp], i);
                        }
                    }

                    j = 0;
                    xmlChild = 0;
                    temp = i.childNodes.length;

                    while (j < temp)
                    {
                        n = {n:-1};
                        if (temp3 = MapInfoItemToXML(i.childNodes[j], n))
                        {
                            //even though it is not written this way in the spec
                            //this is how it works in Firefox
                            x._Children[xmlChild] = temp3;
                            x._Children[xmlChild]._Parent = x;

                            if (temp3._Class === "text" && n.n > 0)
                            {
                                j = j + n.n;
                            }

                            ++xmlChild;
                        }

                        ++j;
                    }

                    x._Value = i.textContent || i.text || i.data || "";

                    x._Length = xmlChild;

                    return x;

                    break;
                case DOCUMENT_NODE:
                //firefox won't do this
                //return MapInfoItemToXML(document.documentElement);
                //break;
                case ENTITY_REFERENCE_NODE:
                    throw new TypeError();
                    break;
                default:
                    return null;
                    break;
            }
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XML
         *    @throws TypeError
         */
        function ToXMLList (s)
        {
            var e,x,list,i,l;

            if (s instanceof XMLList)
            {
                return s;
            }
            else if (s instanceof XML)
            {
                list = new XMLList();
                list._Children[0] = list[0] = s;
                list._TargetObject = x._Parent;
                list._TargetProperty = x._Name;

                return list;
            }
            else if ((",string,boolean,number,").indexOf("," + typeof(s)+",") === -1)
            {
                throw new TypeError();
            }

            e = parse('<parent xmlns="' + GetDefaultNamespace() + '">' + s + '</parent>');
            x = ToXML(e.documentElement);
            list = new XMLList();
            i = 0;
            l = x._Children.length;

            list._TargetObject = null;

            for (;i < l; ++i)
            {
                x._Children[i]._Parent = null;
                list._Children[i] = list[i] = x._Children[i];
            }


            return list;
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XMLList
         *    @throws TypeError
         */
        function ToAttributeName (s)
        {
            if (s === "*")
            {
                return new AttributeName(new QName(null, "*"));
            }
            else if (s instanceof QName)
            {
                return new AttributeName(s);
            }
            else if (s instanceof AttributeName)
            {
                return s;
            }

            switch (typeof(s))
            {
                case "undefined":
                case "null":
                case "boolean":
                case "number":
                    throw new TypeError();
                    break;
                case "string":
                    return new AttributeName(new QName(null, (s + "").replace(/^@/,"")));
                    break;
                case "object":
                    return new AttributeName(new QName(null, ToString(s)));
                    break;
            }
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns QName | AttributeName
         *    @throws TypeError
         */
        function ToXMLName (s)
        {
            if (s instanceof QName || s instanceof AttributeName)
            {
                return s;
            }
            else if (s === "*")
            {
                return new QName("*");
            }

            switch (typeof(s))
            {
                case "undefined":
                case "null":
                case "boolean":
                case "number":
                    throw new TypeError();
                    break;
                case "string":
                    if (s.charAt(0) === "@")
                    {
                        return ToAttributeName( s.substr(0) );
                    }

                    return new QName(s);

                    break;
                case "object":
                    return ToXMLName( ToString(s) );
                    break;
            }
        }

        /**
         *
         *
         *    @returns String
         */
        function GetDefaultNamespace ()
        {
            return !!defaultNamespace && defaultNamespace.uri || "";
        }

        /**
         *
         *
         *    @param String s
         *    @returns String
         */
        function EscapeElementValue (s)
        {
            return ((s||"")+"").replace(/./g, function (c)
            {
                switch (c)
                {
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    default:
                        return c;
                }
            });
        }

        /**
         *
         *
         *
         *    @param String s
         *    @returns String
         */
        function EscapeAttributeValue (s)
        {
            return ((s||"")+"").replace(/./g, function (c)
            {
                switch (c)
                {
                    case '"':
                        return "&quot;";
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    case "\r":
                        return "&#xA;";
                    case "\n":
                        return "&#xD;";
                    case "\t":
                        return "&#x9;";
                    default:
                        return c;
                }
            });
        }

        /**
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function Get (PropertyName)
        {
            if (this instanceof XMLList)
            {
                return GetList.call(this, PropertyName);
            }

            if (parseInt(PropertyName)+"" == PropertyName)
            {
                return GetList.call(ToXMLList(this), PropertyName );
            }

            var n = ToXMLName(PropertyName),
                list = new XMLList(), p, l;

            list._TargetObject = this;
            list._TargetProperty = n;

            if (n instanceof AttributeName)
            {
                for (p in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[p]._Name.localName)
                            &&
                            (n._Name.uri == null || n._Name.uri === this._Attributes[p]._Name.uri)
                        )
                    {
                        list.Append(this._Attributes[p]);
                    }
                }
            }
            else
            {
                for (p = 0, l = this._Children.length; p < l; ++p)
                {
                    if (
                        (n.localName === "*" || (this._Children[p]._Class === "element" && this._Children[p]._Name.localName === n.localName))
                            &&
                            (n.uri == null || (this._Children[p]._Class === "element" && n.uri === this._Children[p]._Name.uri))
                        )
                    {
                        list.Append(this._Children[p]);
                    }
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName P
         *    @returns Boolean
         */
        function HasProperty (P)
        {
            if (this instanceof XMLList)
            {
                return HasPropertyList.call(this, P);
            }

            if (parseInt(P) == P)
            {
                return P == "0";
            }

            var n = ToXMLName(P), k, l;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (
                            n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName
                            ) &&
                            (
                                n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri
                                )
                        )
                    {
                        return true;
                    }
                }

                return false;
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName === n.localName))
                        &&
                        (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                    )
                {
                    return true;
                }
            }

            return false;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns Boolean
         *    @throws TypeError
         */
        function DeleteByIndex (PropertyName)
        {
            var i = parseInt(PropertyName);//, q = i + 1, l = this._Children.length;

            if (i == PropertyName)
            {
                if (!!this._Children[i])
                {
                    this._Children[i]._Parent = null;

                    this._Children[i] = null;

                    this._Children.splice(i, 1);

                    /*
                     for (;q < l;++q)
                     {
                     this._Children[q-1] = this._Children[q];
                     }
                     */
                }

                return true;
            }

            throw new TypeError();
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XML
         */
        function DeepCopy ()
        {
            if (this instanceof XMLList)
            {
                return DeepCopyList.call(this);
            }

            var y = new XML(), i, l;//, c, t;

            y._Class = this._Class;
            y._Name = this._Name;
            y._DefaultNamespace = this._DefaultNamespace ? new Namespace(this._DefaultNamespace) : null;
            y._Value = this._Value;
            y._Parent = null;

            for (i in this._InScopeNamespaces)
            {
                y._InScopeNamespaces[i] = new Namespace(this._InScopeNamespaces.prefix, this._InScopeNamespaces.uri);
            }

            for (l in this._Attributes)
            {
                //y._Attributes[i] = arguments.callee.call(this._Attributes[i]);
                //not part of the spec
                y._Attributes[i] = this._Attributes[l].copy();
                y._Attributes[i]._Parent = y;
            }

            for (i = 0, l = this._Children.length; i < l; ++i)
            {
                y._Children[i] = this._Children[i].copy();
                y._Children[i]._Parent = y;
            }

            return y;
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XML
         */
        function ResolveValue ()
        {
            if (this instanceof XMLList)
            {
                return ResolveValueList.call(this);
            }
            return this instanceof XML ? this : null;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function Descendants (PropertyName)
        {
            if (this instanceof XMLList)
            {
                return DescendantsList.call(this, PropertyName);
            }

            var n = ToXMLName(PropertyName),
                list = new XMLList(),
                k, l, dq;

            list._TargetObject = null;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName)
                            &&
                            (n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri)
                        )
                    {
                        list.Append(this._Attributes[k]);
                    }
                }
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName === n.localName))
                        &&
                        (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                    )
                {
                    list.Append(this._Children[k]);
                }

                dq = this._Children[k].descendants(n);

                if (dq.length() > 0)
                {
                    list.Append(dq);
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML Value
         *    @returns null
         *    @throws TypeError | Error
         */
        function Insert (PropertyName, Value)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            var i = parseInt(PropertyName), n, j;

            if (i+"" != PropertyName)
            {
                throw new TypeError("'" + i + "' != '" + PropertyName + "'");
            }

            if (Value === this || indexOf("," + this, Value.descendants("*")) > -1)
            {
                throw new Error();
            }

            n = Value.length();

            for (j = this._Children.length - 1; j >= i; --j)
            {
                this._Children[ j + n ] = this._Children[j];
            }


            if (Value instanceof XMLList)
            {
                for (j = 0; j < n; ++j)
                {
                    Value[j]._Parent = this;
                    this._Children[i + j] = Value[j];
                }
            }
            else
            {
                Replace.call(this, i, Value);
            }

            return null;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML Value
         *    @returns null
         *    @throws TypeError
         */
        function Replace (PropertyName, Value)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var i = parseInt(PropertyName), t;

            if (i+"" != PropertyName)
            {
                throw new TypeError("'" + i + "' != '" + PropertyName + "'");
            }

            if (i >= this._Children.length)
            {
                PropertyName = this._Children.length;
            }

            if (Value instanceof XMLList)
            {
                DeleteByIndex.call(this, PropertyName);
                Insert.call(this, PropertyName, Value);
            }
            else if (Value instanceof XML
                && Value._Class === "element"
                && (",element,comment,processing-instruction,text").indexOf("," + Value._Class + ",") > -1
                )
            {
                Value._Parent = this;

                if (this._Children[PropertyName])
                {
                    this._Children[PropertyName]._Parent = null;
                }

                this._Children[PropertyName] = Value;
            }
            else
            {
                t = new XML();
                t._Parent = this;
                t._Value = ToString(Value);

                if (this._Children[PropertyName])
                {
                    this._Children[PropertyName]._Parent = null;
                }

                this._Children[PropertyName] = t;
            }
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Namespace NameSpace
         *    @returns null
         */
        function AddInScopeNamespace (NameSpace)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var match = null, p;

            if (NameSpace.prefix == "" && this._Name.uri == "")
            {
                return null;
            }

            for (p in this._InScopeNamespaces)
            {
                if (NameSpace.prefix === this._InScopeNamespaces[p].prefix)
                {
                    match = this._InScopeNamespaces[p];
                }
            }

            if (match && match.uri != NameSpace.uri)
            {
                this._InScopeNamespaces[match.prefix] = null;
                try{
                    delete this._InScopeNamespaces[match.prefix];
                }catch(e){}
            }

            this._InScopeNamespaces[NameSpace.prefix] = NameSpace;

            if (this._Name.prefix === NameSpace.prefix)
            {
                this._Name.prefix = undefined;
            }

            for (p in this._Attributes)
            {
                if (this._Attributes[p]._Name.prefix = NameSpace.prefix)
                {
                    this._Attributes[p]._Name.prefix = undefined;
                }
            }

            //do this in order to ensure namespace integrity
            /*match = parse(this.toXMLString());
             this._Node = !!this._Node.parentNode
             ? this._Node.parentNode.replaceChild(match.documentElement, this._Node)
             : match;*/
        }

        /**
         *
         *
         *    @access private
         *    @param String | Number name
         *    @returns Boolean
         */
        function HasPropertyList (name)
        {
            if (ToString( parseInt(name) ) === name)
            {
                return parseInt(name) < this._Children.length;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this[i]._Class === "element" && this[i].hasOwnProperty(name))
                {
                    return true;
                }
            }

            return false;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @returns XMLList
         */
        function GetList (PropertyName)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                return this[PropertyName];
            }

            var list = new XMLList(), i = 0, l = this._Children.length, temp;
            list._TargetObject = this;
            list._TargetProperty = PropertyName;

            for (;i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    temp = Get.call(this._Children[i], PropertyName);

                    if (temp._Children.length > 0)
                    {
                        list.Append(temp);
                    }
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XMLList
         */
        function DeepCopyList ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;

            list._TargetObject = this._TargetObject;
            list._TargetProperty = this._TargetProperty;
            list._Class = this._Class;
            list._Value = this._Value;

            for (;i < l; ++i)
            {
                list.Append(DeepCopy.call(this[i]));
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function DescendantsList (PropertyName)
        {
            var list = new XMLList(), i = 0, l = this._Children.length, temp;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    if ((temp = Descendants.call(this[i], "*")) && temp.length() > 0)
                    {
                        list.Append(temp);
                    }
                }
            }

            return list;
        }

        /**
         *    http://blog.stevenlevithan.com/archives/faster-trim-javascript
         *
         *
         *    @param String s
         *    @returns String
         */
        function trim (str)
        {
            if(!str)
                return str;
            var    str = str.replace(/^\s\s*/, ""),
                ws = /\s/,
                i = str.length;
            while (ws.test(str.charAt(--i)));
            return str.slice(0, i + 1);
        }

        /**
         *    Generates a prefix for a QName that is not already
         *    a property of the optional argument
         *
         *    @param Object prefixes
         *    @returns String
         */
        function newPrefix (prefixes)
        {
            prefixes = prefixes || {};

            var num = Math.random()
                .toString()
                .substr(2)
                .replace(/.{2}/g, function (a)
                {
                    a = Number(a);
                    return (a > 90 ? 90 : (a < 65 ? 65 : a)) + "";
                });

            num = String.fromCharCode(
                Number(num.substr(0, 2)) & 0xFF,
                Number(num.substr(2, 2)) & 0xFF,
                Number(num.substr(4, 2)) & 0xFF,
                Number(num.substr(6, 2)) & 0xFF,
                Number(num.substr(8, 2)) & 0xFF,
                Number(num.substr(10, 2)) & 0xFF
            ).toLowerCase();

            while (num in prefixes)
            {
                num = arguments.callee(prefixes);
            }

            return num;
        }

        /**
         *
         *
         *    @param String str
         *    @returns DOMNode
         *    @throws SyntaxError
         */
        function parse (str)
        {
            var xmlDoc, success = true;

            if (isActiveXSupported("Microsoft.XMLDOM")) //Internet Explorer
            {
                try{
                    xmlDoc                      = new ActiveXObject("Microsoft.XMLDOM");
                    xmlDoc.async                = 'false';
                    xmlDoc.preserveWhiteSpace   = true;
                    xmlDoc.resolveExternals     = false;
                    xmlDoc.validateOnParse         = false;
                    xmlDoc.setProperty('ProhibitDTD', false);
                    success = xmlDoc.loadXML(str);
                }catch(e){}
            }
            else
            {
                try{//Firefox, Mozilla, Opera, etc.
                    xmlDoc = new DOMParser();
                    xmlDoc = xmlDoc.parseFromString(str, "text/xml");
                }catch(e){}
            }

            if (!success || !xmlDoc || xmlDoc.documentElement.nodeName == "parsererror")
            {
                throw new SyntaxError(!!xmlDoc && xmlDoc.documentElement.childNodes[0].nodeValue);
            }

            return xmlDoc;
        }

        /**
         *
         *
         *    @param Object obj
         *    @returns Number
         */
        function count (obj)
        {
            if ("__count__" in obj)
            {
                return obj.__count__;
            }

            var i = 0, k;

            for (k in obj)
            {
                if (obj.hasOwnProperty(k))
                {
                    ++i;
                }
            }

            return i;
        }

        /**
         *
         *
         *    @param Object obj
         *    @param XMLList list
         *    @returns Number
         */
        function indexOf (obj, list)
        {
            for (var i = 0, l = list.length(); i < l; ++i)
            {
                if (list[i].Equals(obj))
                {
                    return i;
                }
            }

            return -1;
        }

        /**
         *
         *
         *    @param mixed obj
         *    @param mixed ...
         *    @returns mixed
         */
        function extend (obj)
        {
            for (var p, i = 1, l = arguments.length; i < l; ++i)
            {
                for (p in arguments[i])
                {
                    obj[p] = arguments[i][p];
                }
            }

            return obj;
        }

        /**
         *
         *
         *
         */
        function createDocumentFrom (xml)
        {
            return parse(xml.length() == 1 ? xml.toXMLString() : "<x>" + xml.toXMLString() + "</x>");
        }

        /**
         *
         *
         *
         */
        function xmlToDomNode (xml)
        {
            switch (xml.nodeKind())
            {
                case "element":
                    return createDocumentFrom(xml).documentElement;

                case "text":
                    return xmlDoc.createTextNode(xml.toString());

                case "comment":
                    return xmlDoc.createComment(xml.toString().slice(4, -3));

                case "processing-instruction":
                    return xmlDoc.createProcessingInstruction(
                        xml.localName(),
                        xml.toString().slice(2, -2).replace(piName, "")
                    );

                case "attribute":
                    return createAttributeNS(xml);
            }
            return null;
        }

        function adoptNode (doc, node)
        {
            if (!!doc.adoptNode)
            {
                return doc.adoptNode(node);
            }

            var b = doc.documentElement || doc.body;
            return b.removeChild(b.appendChild(node));
        }

        function evaluate (doc, expr, xml)
        {
            var res, l, n = "";

            if (!!doc.evaluate)
            {
                res = doc.evaluate(
                    expr,
                    doc,
                    doc.createNSResolver(doc),
                    XPathResult.ORDERED_NODE_ITERATOR_TYPE,
                    null
                );

                l = [];

                while(n = res.iterateNext())
                {
                    l[l.length] = n;
                }

                return l;
            }

            if ("setProperty" in doc){

                res = allNamespaces(xml);

                if (count(res))
                {
                    for (l in res)
                    {
                        n += " xmlns:" + l + '="' + EscapeAttributeValue(res[l]) + '"';
                    }

                    doc.setProperty('SelectionNamespaces', n.substr(1));
                }

                doc.setProperty("SelectionLanguage", "XPath");
            }

            return isActiveXSupported("Microsoft.XMLDOM") && doc.selectNodes(expr);
        }

        function isActiveXSupported(type) {
            try {
                new ActiveXObject(type);
                return true;
            } catch (e) {
                return false;
            }
        }

        function allNamespaces (xml, un)
        {
            var ns = un || {},
                i = 0,
                c = xml.children(),
                l = c.length(),
                n = un == undefined
                    ? inscope(xml)
                    : xml._InScopeNamespaces,
                p;

            for (;i < l; ++i)
            {
                ns = arguments.callee(c[i], ns);
            }

            for (p in n)
            {
                if (n[p].prefix)
                {
                    ns[n[p].prefix] = n[p].uri;
                }
            }

            return ns;
        }

        function inscope (xml)
        {
            var ns = {},
                i = 0,
                n = xml.inScopeNamespaces(),
                l = n.length;

            for (;i < l; ++i)
            {
                if (n[i].prefix)
                {
                    ns[n[i].prefix] = n[i].uri;
                }
            }

            return ns;
        }

        function createAttributeNS (xml)
        {
            var ns = xml.namespace(),
                node = !!xmlDoc.createAttributeNS
                    ? xmlDoc.createAttributeNS(ns.uri, xml.localName())
                    : xmlDoc.createAttribute((ns.prefix ? ns.prefix + ":" : "" ) + xml.localName());

            node.nodeValue = xml.toString();
            return node;
        }

        function transform (xml, style, params)
        {
            var xsl, res, i = 0, l = (params||[]).length;

            if (!window.XSLTProcessor)
            {
                //TODO: Need to create a way to set parameters on an IE stylesheet
                //XSLProcessor
                //http://msdn.microsoft.com/en-us/library/ms757015%28v=VS.85%29.aspx
                //http://msdn.microsoft.com/en-us/library/ms763679%28VS.85%29.aspx
                //http://msdn.microsoft.com/en-us/library/ms754594%28v=VS.85%29.aspx

                res = createDocumentFrom(xml).transformNode(createDocumentFrom(style));

                return !!res && ToXML(res) || null;
            }

            xsl = new XSLTProcessor();

            xsl.importStyleSheet(createDocumentFrom(style));

            for (; i < l; ++i)
            {
                res = params[i];
                xsl.setParameter(res.namespaceURI, res.localName, res.value);
            }

            res = xsl.transformToDocument(createDocumentFrom(doc))

            return !!res && ToXML(res) || null;
        }

        for (p in XML.prototype)
        {
            defaultXMLPrototype += p + ",";
        }

        for (p in XMLList.prototype)
        {
            defaultXMLListPrototype += p + ",";
        }

        /**
         *
         *
         *
         */
        window.XML              = XML;
        window.XMLList          = XMLList;
        window.QName            = QName;
        window.Namespace        = Namespace;
        window.isXMLName        = isXMLName;
        window.AttributeName    = AttributeName;

    })();
}
(function(){var h=this;
function aa(a){var b=typeof a;if("object"==b)if(a){if(a instanceof Array)return"array";if(a instanceof Object)return b;var c=Object.prototype.toString.call(a);if("[object Window]"==c)return"object";if("[object Array]"==c||"number"==typeof a.length&&"undefined"!=typeof a.splice&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("splice"))return"array";if("[object Function]"==c||"undefined"!=typeof a.call&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("call"))return"function"}else return"null";else if("function"==
b&&"undefined"==typeof a.call)return"object";return b}function k(a){return"string"==typeof a}function ba(a,b,c){return a.call.apply(a.bind,arguments)}function ca(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var c=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(c,d);return a.apply(b,c)}}return function(){return a.apply(b,arguments)}}
function da(a,b,c){da=Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?ba:ca;return da.apply(null,arguments)}function ea(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var b=c.slice();b.push.apply(b,arguments);return a.apply(this,b)}}
function m(a){var b=n;function c(){}c.prototype=b.prototype;a.u=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.t=function(a,c,f){return b.prototype[c].apply(a,Array.prototype.slice.call(arguments,2))}};var fa=String.prototype.trim?function(a){return a.trim()}:function(a){return a.replace(/^[\s\xa0]+|[\s\xa0]+$/g,"")};function ga(a,b){return a<b?-1:a>b?1:0};var q;a:{var ha=h.navigator;if(ha){var ia=ha.userAgent;if(ia){q=ia;break a}}q=""}function r(a){return-1!=q.indexOf(a)};var s=Array.prototype,ja=s.indexOf?function(a,b,c){return s.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if(k(a))return k(b)&&1==b.length?a.indexOf(b,c):-1;for(;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1},t=s.forEach?function(a,b,c){s.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=k(a)?a.split(""):a,f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)},ka=s.filter?function(a,b,c){return s.filter.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=[],f=0,g=k(a)?
a.split(""):a,l=0;l<d;l++)if(l in g){var p=g[l];b.call(c,p,l,a)&&(e[f++]=p)}return e},u=s.reduce?function(a,b,c,d){d&&(b=da(b,d));return s.reduce.call(a,b,c)}:function(a,b,c,d){var e=c;t(a,function(c,g){e=b.call(d,e,c,g,a)});return e},la=s.some?function(a,b,c){return s.some.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=k(a)?a.split(""):a,f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return!0;return!1};
function ma(a,b){var c;a:{c=a.length;for(var d=k(a)?a.split(""):a,e=0;e<c;e++)if(e in d&&b.call(void 0,d[e],e,a)){c=e;break a}c=-1}return 0>c?null:k(a)?a.charAt(c):a[c]}function na(a){return s.concat.apply(s,arguments)}function oa(a,b,c){return 2>=arguments.length?s.slice.call(a,b):s.slice.call(a,b,c)};var pa=r("Opera")||r("OPR"),v=r("Trident")||r("MSIE"),qa=r("Gecko")&&-1==q.toLowerCase().indexOf("webkit")&&!(r("Trident")||r("MSIE")),ra=-1!=q.toLowerCase().indexOf("webkit");function sa(){var a=h.document;return a?a.documentMode:void 0}
var ta=function(){var a="",b;if(pa&&h.opera)return a=h.opera.version,"function"==aa(a)?a():a;qa?b=/rv\:([^\);]+)(\)|;)/:v?b=/\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/:ra&&(b=/WebKit\/(\S+)/);b&&(a=(a=b.exec(q))?a[1]:"");return v&&(b=sa(),b>parseFloat(a))?String(b):a}(),ua={};
function va(a){if(!ua[a]){for(var b=0,c=fa(String(ta)).split("."),d=fa(String(a)).split("."),e=Math.max(c.length,d.length),f=0;0==b&&f<e;f++){var g=c[f]||"",l=d[f]||"",p=RegExp("(\\d*)(\\D*)","g"),x=RegExp("(\\d*)(\\D*)","g");do{var C=p.exec(g)||["","",""],X=x.exec(l)||["","",""];if(0==C[0].length&&0==X[0].length)break;b=ga(0==C[1].length?0:parseInt(C[1],10),0==X[1].length?0:parseInt(X[1],10))||ga(0==C[2].length,0==X[2].length)||ga(C[2],X[2])}while(0==b)}ua[a]=0<=b}}
var wa=h.document,xa=wa&&v?sa()||("CSS1Compat"==wa.compatMode?parseInt(ta,10):5):void 0;!qa&&!v||v&&v&&9<=xa||qa&&va("1.9.1");v&&va("9");function ya(a,b){if(a.contains&&1==b.nodeType)return a==b||a.contains(b);if("undefined"!=typeof a.compareDocumentPosition)return a==b||Boolean(a.compareDocumentPosition(b)&16);for(;b&&a!=b;)b=b.parentNode;return b==a}
function za(a,b){if(a==b)return 0;if(a.compareDocumentPosition)return a.compareDocumentPosition(b)&2?1:-1;if(v&&!(v&&9<=xa)){if(9==a.nodeType)return-1;if(9==b.nodeType)return 1}if("sourceIndex"in a||a.parentNode&&"sourceIndex"in a.parentNode){var c=1==a.nodeType,d=1==b.nodeType;if(c&&d)return a.sourceIndex-b.sourceIndex;var e=a.parentNode,f=b.parentNode;return e==f?Aa(a,b):!c&&ya(e,b)?-1*Ba(a,b):!d&&ya(f,a)?Ba(b,a):(c?a.sourceIndex:e.sourceIndex)-(d?b.sourceIndex:f.sourceIndex)}d=9==a.nodeType?a:
a.ownerDocument||a.document;c=d.createRange();c.selectNode(a);c.collapse(!0);d=d.createRange();d.selectNode(b);d.collapse(!0);return c.compareBoundaryPoints(h.Range.START_TO_END,d)}function Ba(a,b){var c=a.parentNode;if(c==b)return-1;for(var d=b;d.parentNode!=c;)d=d.parentNode;return Aa(d,a)}function Aa(a,b){for(var c=b;c=c.previousSibling;)if(c==a)return-1;return 1};function w(a,b,c){this.a=a;this.b=b||1;this.d=c||1};function Ca(a){this.b=a;this.a=0}function Da(a){a=a.match(Ea);for(var b=0;b<a.length;b++)Fa.test(a[b])&&a.splice(b,1);return new Ca(a)}var Ea=RegExp("\\$?(?:(?![0-9-])[\\w-]+:)?(?![0-9-])[\\w-]+|\\/\\/|\\.\\.|::|\\d+(?:\\.\\d*)?|\\.\\d+|\"[^\"]*\"|'[^']*'|[!<>]=|\\s+|.","g"),Fa=/^\s/;function y(a,b){return a.b[a.a+(b||0)]}function z(a){return a.b[a.a++]}function Ga(a){return a.b.length<=a.a};function A(a,b){this.h=a.toLowerCase();this.c=b?b.toLowerCase():"http://www.w3.org/1999/xhtml"}A.prototype.a=function(a){var b=a.nodeType;return 1!=b&&2!=b?!1:"*"!=this.h&&this.h!=a.nodeName.toLowerCase()?!1:this.c==(a.namespaceURI?a.namespaceURI.toLowerCase():"http://www.w3.org/1999/xhtml")};A.prototype.d=function(){return this.h};A.prototype.toString=function(){return"Name Test: "+("http://www.w3.org/1999/xhtml"==this.c?"":this.c+":")+this.h};function B(a,b){this.f=a;this.c=void 0!==b?b:null;this.b=null;switch(a){case "comment":this.b=8;break;case "text":this.b=3;break;case "processing-instruction":this.b=7;break;case "node":break;default:throw Error("Unexpected argument");}}function Ha(a){return"comment"==a||"text"==a||"processing-instruction"==a||"node"==a}B.prototype.a=function(a){return null===this.b||this.b==a.nodeType};B.prototype.d=function(){return this.f};
B.prototype.toString=function(){var a="Kind Test: "+this.f;null===this.c||(a+=D(this.c));return a};function Ia(a){switch(a.nodeType){case 1:return ea(Ja,a);case 9:return Ia(a.documentElement);case 11:case 10:case 6:case 12:return Ka;default:return a.parentNode?Ia(a.parentNode):Ka}}function Ka(){return null}function Ja(a,b){if(a.prefix==b)return a.namespaceURI||"http://www.w3.org/1999/xhtml";var c=a.getAttributeNode("xmlns:"+b);return c&&c.specified?c.value||null:a.parentNode&&9!=a.parentNode.nodeType?Ja(a.parentNode,b):null};var E=v&&!(v&&9<=xa),La=v&&!(v&&8<=xa);function F(a,b,c,d){this.a=a;this.nodeName=c;this.nodeValue=d;this.nodeType=2;this.parentNode=this.ownerElement=b}function Ma(a,b){var c=La&&"href"==b.nodeName?a.getAttribute(b.nodeName,2):b.nodeValue;return new F(b,a,b.nodeName,c)};function G(a){var b=null,c=a.nodeType;1==c&&(b=a.textContent,b=void 0==b||null==b?a.innerText:b,b=void 0==b||null==b?"":b);if("string"!=typeof b)if(E&&"title"==a.nodeName.toLowerCase()&&1==c)b=a.text;else if(9==c||1==c){a=9==c?a.documentElement:a.firstChild;for(var c=0,d=[],b="";a;){do 1!=a.nodeType&&(b+=a.nodeValue),E&&"title"==a.nodeName.toLowerCase()&&(b+=a.text),d[c++]=a;while(a=a.firstChild);for(;c&&!(a=d[--c].nextSibling););}}else b=a.nodeValue;return""+b}
function H(a,b,c){if(null===b)return!0;try{if(!a.getAttribute)return!1}catch(d){return!1}La&&"class"==b&&(b="className");return null==c?!!a.getAttribute(b):a.getAttribute(b,2)==c}function I(a,b,c,d,e){return(E?Na:Oa).call(null,a,b,k(c)?c:null,k(d)?d:null,e||new J)}
function Na(a,b,c,d,e){if(a instanceof A||8==a.b||c&&null===a.b){var f=b.all;if(!f)return e;a=Pa(a);if("*"!=a&&(f=b.getElementsByTagName(a),!f))return e;if(c){for(var g=[],l=0;b=f[l++];)H(b,c,d)&&g.push(b);f=g}for(l=0;b=f[l++];)"*"==a&&"!"==b.tagName||K(e,b);return e}Qa(a,b,c,d,e);return e}
function Oa(a,b,c,d,e){b.getElementsByName&&d&&"name"==c&&!v?(b=b.getElementsByName(d),t(b,function(b){a.a(b)&&K(e,b)})):b.getElementsByClassName&&d&&"class"==c?(b=b.getElementsByClassName(d),t(b,function(b){b.className==d&&a.a(b)&&K(e,b)})):a instanceof B?Qa(a,b,c,d,e):b.getElementsByTagName&&(b=b.getElementsByTagName(a.d()),t(b,function(a){H(a,c,d)&&K(e,a)}));return e}
function Ra(a,b,c,d,e){var f;if((a instanceof A||8==a.b||c&&null===a.b)&&(f=b.childNodes)){var g=Pa(a);if("*"!=g&&(f=ka(f,function(a){return a.tagName&&a.tagName.toLowerCase()==g}),!f))return e;c&&(f=ka(f,function(a){return H(a,c,d)}));t(f,function(a){"*"==g&&("!"==a.tagName||"*"==g&&1!=a.nodeType)||K(e,a)});return e}return Sa(a,b,c,d,e)}function Sa(a,b,c,d,e){for(b=b.firstChild;b;b=b.nextSibling)H(b,c,d)&&a.a(b)&&K(e,b);return e}
function Qa(a,b,c,d,e){for(b=b.firstChild;b;b=b.nextSibling)H(b,c,d)&&a.a(b)&&K(e,b),Qa(a,b,c,d,e)}function Pa(a){if(a instanceof B){if(8==a.b)return"!";if(null===a.b)return"*"}return a.d()};function J(){this.b=this.a=null;this.i=0}function Ta(a){this.d=a;this.a=this.b=null}function Ua(a,b){if(!a.a)return b;if(!b.a)return a;for(var c=a.a,d=b.a,e=null,f=null,g=0;c&&d;){var f=c.d,l=d.d;f==l||f instanceof F&&l instanceof F&&f.a==l.a?(f=c,c=c.a,d=d.a):0<za(c.d,d.d)?(f=d,d=d.a):(f=c,c=c.a);(f.b=e)?e.a=f:a.a=f;e=f;g++}for(f=c||d;f;)f.b=e,e=e.a=f,g++,f=f.a;a.b=e;a.i=g;return a}function Va(a,b){var c=new Ta(b);c.a=a.a;a.b?a.a.b=c:a.a=a.b=c;a.a=c;a.i++}
function K(a,b){var c=new Ta(b);c.b=a.b;a.a?a.b.a=c:a.a=a.b=c;a.b=c;a.i++}function Wa(a){return(a=a.a)?a.d:null}function Xa(a){return(a=Wa(a))?G(a):""}function L(a,b){return new Ya(a,!!b)}function Ya(a,b){this.d=a;this.b=(this.c=b)?a.b:a.a;this.a=null}function M(a){var b=a.b;if(null==b)return null;var c=a.a=b;a.b=a.c?b.b:b.a;return c.d};function n(a){this.g=a;this.b=this.e=!1;this.d=null}function D(a){return"\n  "+a.toString().split("\n").join("\n  ")}function Za(a,b){a.e=b}function $a(a,b){a.b=b}function N(a,b){var c=a.a(b);return c instanceof J?+Xa(c):+c}function O(a,b){var c=a.a(b);return c instanceof J?Xa(c):""+c}function P(a,b){var c=a.a(b);return c instanceof J?!!c.i:!!c};function Q(a,b,c){n.call(this,a.g);this.c=a;this.f=b;this.k=c;this.e=b.e||c.e;this.b=b.b||c.b;this.c==ab&&(c.b||c.e||4==c.g||0==c.g||!b.d?b.b||b.e||4==b.g||0==b.g||!c.d||(this.d={name:c.d.name,l:b}):this.d={name:b.d.name,l:c})}m(Q);
function R(a,b,c,d,e){b=b.a(d);c=c.a(d);var f;if(b instanceof J&&c instanceof J){e=L(b);for(d=M(e);d;d=M(e))for(b=L(c),f=M(b);f;f=M(b))if(a(G(d),G(f)))return!0;return!1}if(b instanceof J||c instanceof J){b instanceof J?e=b:(e=c,c=b);e=L(e);b=typeof c;for(d=M(e);d;d=M(e)){switch(b){case "number":d=+G(d);break;case "boolean":d=!!G(d);break;case "string":d=G(d);break;default:throw Error("Illegal primitive type for comparison.");}if(a(d,c))return!0}return!1}return e?"boolean"==typeof b||"boolean"==typeof c?
a(!!b,!!c):"number"==typeof b||"number"==typeof c?a(+b,+c):a(b,c):a(+b,+c)}Q.prototype.a=function(a){return this.c.j(this.f,this.k,a)};Q.prototype.toString=function(){var a="Binary Expression: "+this.c,a=a+D(this.f);return a+=D(this.k)};function bb(a,b,c,d){this.a=a;this.p=b;this.g=c;this.j=d}bb.prototype.toString=function(){return this.a};var cb={};function S(a,b,c,d){if(cb.hasOwnProperty(a))throw Error("Binary operator already created: "+a);a=new bb(a,b,c,d);return cb[a.toString()]=a}
S("div",6,1,function(a,b,c){return N(a,c)/N(b,c)});S("mod",6,1,function(a,b,c){return N(a,c)%N(b,c)});S("*",6,1,function(a,b,c){return N(a,c)*N(b,c)});S("+",5,1,function(a,b,c){return N(a,c)+N(b,c)});S("-",5,1,function(a,b,c){return N(a,c)-N(b,c)});S("<",4,2,function(a,b,c){return R(function(a,b){return a<b},a,b,c)});S(">",4,2,function(a,b,c){return R(function(a,b){return a>b},a,b,c)});S("<=",4,2,function(a,b,c){return R(function(a,b){return a<=b},a,b,c)});
S(">=",4,2,function(a,b,c){return R(function(a,b){return a>=b},a,b,c)});var ab=S("=",3,2,function(a,b,c){return R(function(a,b){return a==b},a,b,c,!0)});S("!=",3,2,function(a,b,c){return R(function(a,b){return a!=b},a,b,c,!0)});S("and",2,2,function(a,b,c){return P(a,c)&&P(b,c)});S("or",1,2,function(a,b,c){return P(a,c)||P(b,c)});function db(a,b){if(b.a.length&&4!=a.g)throw Error("Primary expression must evaluate to nodeset if filter has predicate(s).");n.call(this,a.g);this.c=a;this.f=b;this.e=a.e;this.b=a.b}m(db);db.prototype.a=function(a){a=this.c.a(a);return eb(this.f,a)};db.prototype.toString=function(){var a;a="Filter:"+D(this.c);return a+=D(this.f)};function fb(a,b){if(b.length<a.o)throw Error("Function "+a.h+" expects at least"+a.o+" arguments, "+b.length+" given");if(null!==a.n&&b.length>a.n)throw Error("Function "+a.h+" expects at most "+a.n+" arguments, "+b.length+" given");a.s&&t(b,function(b,d){if(4!=b.g)throw Error("Argument "+d+" to function "+a.h+" is not of type Nodeset: "+b);});n.call(this,a.g);this.f=a;this.c=b;Za(this,a.e||la(b,function(a){return a.e}));$a(this,a.r&&!b.length||a.q&&!!b.length||la(b,function(a){return a.b}))}m(fb);
fb.prototype.a=function(a){return this.f.j.apply(null,na(a,this.c))};fb.prototype.toString=function(){var a="Function: "+this.f;if(this.c.length)var b=u(this.c,function(a,b){return a+D(b)},"Arguments:"),a=a+D(b);return a};function gb(a,b,c,d,e,f,g,l,p){this.h=a;this.g=b;this.e=c;this.r=d;this.q=e;this.j=f;this.o=g;this.n=void 0!==l?l:g;this.s=!!p}gb.prototype.toString=function(){return this.h};var hb={};
function T(a,b,c,d,e,f,g,l){if(hb.hasOwnProperty(a))throw Error("Function already created: "+a+".");hb[a]=new gb(a,b,c,d,!1,e,f,g,l)}T("boolean",2,!1,!1,function(a,b){return P(b,a)},1);T("ceiling",1,!1,!1,function(a,b){return Math.ceil(N(b,a))},1);T("concat",3,!1,!1,function(a,b){return u(oa(arguments,1),function(b,d){return b+O(d,a)},"")},2,null);T("contains",2,!1,!1,function(a,b,c){b=O(b,a);a=O(c,a);return-1!=b.indexOf(a)},2);T("count",1,!1,!1,function(a,b){return b.a(a).i},1,1,!0);
T("false",2,!1,!1,function(){return!1},0);T("floor",1,!1,!1,function(a,b){return Math.floor(N(b,a))},1);T("id",4,!1,!1,function(a,b){function c(a){if(E){var b=e.all[a];if(b){if(b.nodeType&&a==b.id)return b;if(b.length)return ma(b,function(b){return a==b.id})}return null}return e.getElementById(a)}var d=a.a,e=9==d.nodeType?d:d.ownerDocument,d=O(b,a).split(/\s+/),f=[];t(d,function(a){a=c(a);!a||0<=ja(f,a)||f.push(a)});f.sort(za);var g=new J;t(f,function(a){K(g,a)});return g},1);
T("lang",2,!1,!1,function(){return!1},1);T("last",1,!0,!1,function(a){if(1!=arguments.length)throw Error("Function last expects ()");return a.d},0);T("local-name",3,!1,!0,function(a,b){var c=b?Wa(b.a(a)):a.a;return c?c.localName||c.nodeName.toLowerCase():""},0,1,!0);T("name",3,!1,!0,function(a,b){var c=b?Wa(b.a(a)):a.a;return c?c.nodeName.toLowerCase():""},0,1,!0);T("namespace-uri",3,!0,!1,function(){return""},0,1,!0);
T("normalize-space",3,!1,!0,function(a,b){return(b?O(b,a):G(a.a)).replace(/[\s\xa0]+/g," ").replace(/^\s+|\s+$/g,"")},0,1);T("not",2,!1,!1,function(a,b){return!P(b,a)},1);T("number",1,!1,!0,function(a,b){return b?N(b,a):+G(a.a)},0,1);T("position",1,!0,!1,function(a){return a.b},0);T("round",1,!1,!1,function(a,b){return Math.round(N(b,a))},1);T("starts-with",2,!1,!1,function(a,b,c){b=O(b,a);a=O(c,a);return 0==b.lastIndexOf(a,0)},2);T("string",3,!1,!0,function(a,b){return b?O(b,a):G(a.a)},0,1);
T("string-length",1,!1,!0,function(a,b){return(b?O(b,a):G(a.a)).length},0,1);T("substring",3,!1,!1,function(a,b,c,d){c=N(c,a);if(isNaN(c)||Infinity==c||-Infinity==c)return"";d=d?N(d,a):Infinity;if(isNaN(d)||-Infinity===d)return"";c=Math.round(c)-1;var e=Math.max(c,0);a=O(b,a);if(Infinity==d)return a.substring(e);b=Math.round(d);return a.substring(e,c+b)},2,3);T("substring-after",3,!1,!1,function(a,b,c){b=O(b,a);a=O(c,a);c=b.indexOf(a);return-1==c?"":b.substring(c+a.length)},2);
T("substring-before",3,!1,!1,function(a,b,c){b=O(b,a);a=O(c,a);a=b.indexOf(a);return-1==a?"":b.substring(0,a)},2);T("sum",1,!1,!1,function(a,b){for(var c=L(b.a(a)),d=0,e=M(c);e;e=M(c))d+=+G(e);return d},1,1,!0);T("translate",3,!1,!1,function(a,b,c,d){b=O(b,a);c=O(c,a);var e=O(d,a);a=[];for(d=0;d<c.length;d++){var f=c.charAt(d);f in a||(a[f]=e.charAt(d))}c="";for(d=0;d<b.length;d++)f=b.charAt(d),c+=f in a?a[f]:f;return c},3);T("true",2,!1,!1,function(){return!0},0);function ib(a){n.call(this,3);this.c=a.substring(1,a.length-1)}m(ib);ib.prototype.a=function(){return this.c};ib.prototype.toString=function(){return"Literal: "+this.c};function jb(a){n.call(this,1);this.c=a}m(jb);jb.prototype.a=function(){return this.c};jb.prototype.toString=function(){return"Number: "+this.c};function kb(a,b){n.call(this,a.g);this.f=a;this.c=b;this.e=a.e;this.b=a.b;if(1==this.c.length){var c=this.c[0];c.m||c.c!=lb||(c=c.k,"*"!=c.d()&&(this.d={name:c.d(),l:null}))}}m(kb);function U(){n.call(this,4)}m(U);U.prototype.a=function(a){var b=new J;a=a.a;9==a.nodeType?K(b,a):K(b,a.ownerDocument);return b};U.prototype.toString=function(){return"Root Helper Expression"};function mb(){n.call(this,4)}m(mb);mb.prototype.a=function(a){var b=new J;K(b,a.a);return b};mb.prototype.toString=function(){return"Context Helper Expression"};
function nb(a){return"/"==a||"//"==a}kb.prototype.a=function(a){var b=this.f.a(a);if(!(b instanceof J))throw Error("Filter expression must evaluate to nodeset.");a=this.c;for(var c=0,d=a.length;c<d&&b.i;c++){var e=a[c],f=L(b,e.c.a),g;if(e.e||e.c!=ob)if(e.e||e.c!=pb)for(g=M(f),b=e.a(new w(g));null!=(g=M(f));)g=e.a(new w(g)),b=Ua(b,g);else g=M(f),b=e.a(new w(g));else{for(g=M(f);(b=M(f))&&(!g.contains||g.contains(b))&&b.compareDocumentPosition(g)&8;g=b);b=e.a(new w(g))}}return b};
kb.prototype.toString=function(){var a;a="Path Expression:"+D(this.f);if(this.c.length){var b=u(this.c,function(a,b){return a+D(b)},"Steps:");a+=D(b)}return a};function qb(a,b){this.a=a;this.b=!!b}
function eb(a,b,c){for(c=c||0;c<a.a.length;c++)for(var d=a.a[c],e=L(b),f=b.i,g,l=0;g=M(e);l++){var p=a.b?f-l:l+1;g=d.a(new w(g,p,f));if("number"==typeof g)p=p==g;else if("string"==typeof g||"boolean"==typeof g)p=!!g;else if(g instanceof J)p=0<g.i;else throw Error("Predicate.evaluate returned an unexpected type.");if(!p){p=e;g=p.d;var x=p.a;if(!x)throw Error("Next must be called at least once before remove.");var C=x.b,x=x.a;C?C.a=x:g.a=x;x?x.b=C:g.b=C;g.i--;p.a=null}}return b}
qb.prototype.toString=function(){return u(this.a,function(a,b){return a+D(b)},"Predicates:")};function V(a,b,c,d){n.call(this,4);this.c=a;this.k=b;this.f=c||new qb([]);this.m=!!d;b=this.f;b=0<b.a.length?b.a[0].d:null;a.b&&b&&(a=b.name,a=E?a.toLowerCase():a,this.d={name:a,l:b.l});a:{a=this.f;for(b=0;b<a.a.length;b++)if(c=a.a[b],c.e||1==c.g||0==c.g){a=!0;break a}a=!1}this.e=a}m(V);
V.prototype.a=function(a){var b=a.a,c=null,c=this.d,d=null,e=null,f=0;c&&(d=c.name,e=c.l?O(c.l,a):null,f=1);if(this.m)if(this.e||this.c!=rb)if(a=L((new V(sb,new B("node"))).a(a)),b=M(a))for(c=this.j(b,d,e,f);null!=(b=M(a));)c=Ua(c,this.j(b,d,e,f));else c=new J;else c=I(this.k,b,d,e),c=eb(this.f,c,f);else c=this.j(a.a,d,e,f);return c};V.prototype.j=function(a,b,c,d){a=this.c.d(this.k,a,b,c);return a=eb(this.f,a,d)};
V.prototype.toString=function(){var a;a="Step:"+D("Operator: "+(this.m?"//":"/"));this.c.h&&(a+=D("Axis: "+this.c));a+=D(this.k);if(this.f.a.length){var b=u(this.f.a,function(a,b){return a+D(b)},"Predicates:");a+=D(b)}return a};function tb(a,b,c,d){this.h=a;this.d=b;this.a=c;this.b=d}tb.prototype.toString=function(){return this.h};var ub={};function W(a,b,c,d){if(ub.hasOwnProperty(a))throw Error("Axis already created: "+a);b=new tb(a,b,c,!!d);return ub[a]=b}
W("ancestor",function(a,b){for(var c=new J,d=b;d=d.parentNode;)a.a(d)&&Va(c,d);return c},!0);W("ancestor-or-self",function(a,b){var c=new J,d=b;do a.a(d)&&Va(c,d);while(d=d.parentNode);return c},!0);
var lb=W("attribute",function(a,b){var c=new J,d=a.d();if("style"==d&&b.style&&E)return K(c,new F(b.style,b,"style",b.style.cssText)),c;var e=b.attributes;if(e)if(a instanceof B&&null===a.b||"*"==d)for(var d=0,f;f=e[d];d++)E?f.nodeValue&&K(c,Ma(b,f)):K(c,f);else(f=e.getNamedItem(d))&&(E?f.nodeValue&&K(c,Ma(b,f)):K(c,f));return c},!1),rb=W("child",function(a,b,c,d,e){return(E?Ra:Sa).call(null,a,b,k(c)?c:null,k(d)?d:null,e||new J)},!1,!0);W("descendant",I,!1,!0);
var sb=W("descendant-or-self",function(a,b,c,d){var e=new J;H(b,c,d)&&a.a(b)&&K(e,b);return I(a,b,c,d,e)},!1,!0),ob=W("following",function(a,b,c,d){var e=new J;do for(var f=b;f=f.nextSibling;)H(f,c,d)&&a.a(f)&&K(e,f),e=I(a,f,c,d,e);while(b=b.parentNode);return e},!1,!0);W("following-sibling",function(a,b){for(var c=new J,d=b;d=d.nextSibling;)a.a(d)&&K(c,d);return c},!1);W("namespace",function(){return new J},!1);
var vb=W("parent",function(a,b){var c=new J;if(9==b.nodeType)return c;if(2==b.nodeType)return K(c,b.ownerElement),c;var d=b.parentNode;a.a(d)&&K(c,d);return c},!1),pb=W("preceding",function(a,b,c,d){var e=new J,f=[];do f.unshift(b);while(b=b.parentNode);for(var g=1,l=f.length;g<l;g++){var p=[];for(b=f[g];b=b.previousSibling;)p.unshift(b);for(var x=0,C=p.length;x<C;x++)b=p[x],H(b,c,d)&&a.a(b)&&K(e,b),e=I(a,b,c,d,e)}return e},!0,!0);
W("preceding-sibling",function(a,b){for(var c=new J,d=b;d=d.previousSibling;)a.a(d)&&Va(c,d);return c},!0);var wb=W("self",function(a,b){var c=new J;a.a(b)&&K(c,b);return c},!1);function xb(a){n.call(this,1);this.c=a;this.e=a.e;this.b=a.b}m(xb);xb.prototype.a=function(a){return-N(this.c,a)};xb.prototype.toString=function(){return"Unary Expression: -"+D(this.c)};function yb(a){n.call(this,4);this.c=a;Za(this,la(this.c,function(a){return a.e}));$a(this,la(this.c,function(a){return a.b}))}m(yb);yb.prototype.a=function(a){var b=new J;t(this.c,function(c){c=c.a(a);if(!(c instanceof J))throw Error("Path expression must evaluate to NodeSet.");b=Ua(b,c)});return b};yb.prototype.toString=function(){return u(this.c,function(a,b){return a+D(b)},"Union Expression:")};function zb(a,b){this.a=a;this.b=b}function Ab(a){for(var b,c=[];;){Y(a,"Missing right hand side of binary expression.");b=Bb(a);var d=z(a.a);if(!d)break;var e=(d=cb[d]||null)&&d.p;if(!e){a.a.a--;break}for(;c.length&&e<=c[c.length-1].p;)b=new Q(c.pop(),c.pop(),b);c.push(b,d)}for(;c.length;)b=new Q(c.pop(),c.pop(),b);return b}function Y(a,b){if(Ga(a.a))throw Error(b);}function Cb(a,b){var c=z(a.a);if(c!=b)throw Error("Bad token, expected: "+b+" got: "+c);}
function Db(a){a=z(a.a);if(")"!=a)throw Error("Bad token: "+a);}function Eb(a){a=z(a.a);if(2>a.length)throw Error("Unclosed literal string");return new ib(a)}function Fb(a){var b=z(a.a),c=b.indexOf(":");if(-1==c)return new A(b);var d=b.substring(0,c);a=a.b(d);if(!a)throw Error("Namespace prefix not declared: "+d);b=b.substr(c+1);return new A(b,a)}
function Gb(a){var b,c=[],d;if(nb(y(a.a))){b=z(a.a);d=y(a.a);if("/"==b&&(Ga(a.a)||"."!=d&&".."!=d&&"@"!=d&&"*"!=d&&!/(?![0-9])[\w]/.test(d)))return new U;d=new U;Y(a,"Missing next location step.");b=Hb(a,b);c.push(b)}else{a:{b=y(a.a);d=b.charAt(0);switch(d){case "$":throw Error("Variable reference not allowed in HTML XPath");case "(":z(a.a);b=Ab(a);Y(a,'unclosed "("');Cb(a,")");break;case '"':case "'":b=Eb(a);break;default:if(isNaN(+b))if(!Ha(b)&&/(?![0-9])[\w]/.test(d)&&"("==y(a.a,1)){b=z(a.a);b=
hb[b]||null;z(a.a);for(d=[];")"!=y(a.a);){Y(a,"Missing function argument list.");d.push(Ab(a));if(","!=y(a.a))break;z(a.a)}Y(a,"Unclosed function argument list.");Db(a);b=new fb(b,d)}else{b=null;break a}else b=new jb(+z(a.a))}"["==y(a.a)&&(d=new qb(Ib(a)),b=new db(b,d))}if(b)if(nb(y(a.a)))d=b;else return b;else b=Hb(a,"/"),d=new mb,c.push(b)}for(;nb(y(a.a));)b=z(a.a),Y(a,"Missing next location step."),b=Hb(a,b),c.push(b);return new kb(d,c)}
function Hb(a,b){var c,d,e;if("/"!=b&&"//"!=b)throw Error('Step op should be "/" or "//"');if("."==y(a.a))return d=new V(wb,new B("node")),z(a.a),d;if(".."==y(a.a))return d=new V(vb,new B("node")),z(a.a),d;var f;if("@"==y(a.a))f=lb,z(a.a),Y(a,"Missing attribute name");else if("::"==y(a.a,1)){if(!/(?![0-9])[\w]/.test(y(a.a).charAt(0)))throw Error("Bad token: "+z(a.a));c=z(a.a);f=ub[c]||null;if(!f)throw Error("No axis with name: "+c);z(a.a);Y(a,"Missing node name")}else f=rb;c=y(a.a);if(/(?![0-9])[\w]/.test(c.charAt(0)))if("("==
y(a.a,1)){if(!Ha(c))throw Error("Invalid node type: "+c);c=z(a.a);if(!Ha(c))throw Error("Invalid type name: "+c);Cb(a,"(");Y(a,"Bad nodetype");e=y(a.a).charAt(0);var g=null;if('"'==e||"'"==e)g=Eb(a);Y(a,"Bad nodetype");Db(a);c=new B(c,g)}else c=Fb(a);else if("*"==c)c=Fb(a);else throw Error("Bad token: "+z(a.a));e=new qb(Ib(a),f.a);return d||new V(f,c,e,"//"==b)}
function Ib(a){for(var b=[];"["==y(a.a);){z(a.a);Y(a,"Missing predicate expression.");var c=Ab(a);b.push(c);Y(a,"Unclosed predicate expression.");Cb(a,"]")}return b}function Bb(a){if("-"==y(a.a))return z(a.a),new xb(Bb(a));var b=Gb(a);if("|"!=y(a.a))a=b;else{for(b=[b];"|"==z(a.a);)Y(a,"Missing next union location path."),b.push(Gb(a));a.a.a--;a=new yb(b)}return a};function Jb(a,b){if(!a.length)throw Error("Empty XPath expression.");var c=Da(a);if(Ga(c))throw Error("Invalid XPath expression.");b?"function"==aa(b)||(b=da(b.lookupNamespaceURI,b)):b=function(){return null};var d=Ab(new zb(c,b));if(!Ga(c))throw Error("Bad token: "+z(c));this.evaluate=function(a,b){var c=d.a(new w(a));return new Z(c,b)}}
function Z(a,b){if(0==b)if(a instanceof J)b=4;else if("string"==typeof a)b=2;else if("number"==typeof a)b=1;else if("boolean"==typeof a)b=3;else throw Error("Unexpected evaluation result.");if(2!=b&&1!=b&&3!=b&&!(a instanceof J))throw Error("value could not be converted to the specified type");this.resultType=b;var c;switch(b){case 2:this.stringValue=a instanceof J?Xa(a):""+a;break;case 1:this.numberValue=a instanceof J?+Xa(a):+a;break;case 3:this.booleanValue=a instanceof J?0<a.i:!!a;break;case 4:case 5:case 6:case 7:var d=
L(a);c=[];for(var e=M(d);e;e=M(d))c.push(e instanceof F?e.a:e);this.snapshotLength=a.i;this.invalidIteratorState=!1;break;case 8:case 9:d=Wa(a);this.singleNodeValue=d instanceof F?d.a:d;break;default:throw Error("Unknown XPathResult type.");}var f=0;this.iterateNext=function(){if(4!=b&&5!=b)throw Error("iterateNext called with wrong result type");return f>=c.length?null:c[f++]};this.snapshotItem=function(a){if(6!=b&&7!=b)throw Error("snapshotItem called with wrong result type");return a>=c.length||
0>a?null:c[a]}}Z.ANY_TYPE=0;Z.NUMBER_TYPE=1;Z.STRING_TYPE=2;Z.BOOLEAN_TYPE=3;Z.UNORDERED_NODE_ITERATOR_TYPE=4;Z.ORDERED_NODE_ITERATOR_TYPE=5;Z.UNORDERED_NODE_SNAPSHOT_TYPE=6;Z.ORDERED_NODE_SNAPSHOT_TYPE=7;Z.ANY_UNORDERED_NODE_TYPE=8;Z.FIRST_ORDERED_NODE_TYPE=9;function Kb(a){this.lookupNamespaceURI=Ia(a)}
function Lb(a){a=a||h;var b=a.document;b.evaluate||(a.XPathResult=Z,b.evaluate=function(a,b,e,f){return(new Jb(a,e)).evaluate(b,f)},b.createExpression=function(a,b){return new Jb(a,b)},b.createNSResolver=function(a){return new Kb(a)})}var Mb=["wgxpath","install"],$=h;Mb[0]in $||!$.execScript||$.execScript("var "+Mb[0]);for(var Nb;Mb.length&&(Nb=Mb.shift());)Mb.length||void 0===Lb?$[Nb]?$=$[Nb]:$=$[Nb]={}:$[Nb]=Lb;})()

/**
 * @license wysihtml5 v0.4.0pre
 * https://github.com/xing/wysihtml5
 *
 * Author: Christopher Blum (https://github.com/tiff)
 *
 * Copyright (C) 2012 XING AG
 * Licensed under the MIT license (MIT)
 *
 */
var wysihtml5 = {
    version : "0.4.0pre",

    // namespaces
    commands : {},
    dom : {},
    quirks : {},
    toolbar : {},
    lang : {},
    selection : {},
    views : {},

    INVISIBLE_SPACE : "\uFEFF",

    EMPTY_FUNCTION : function () {
    },

    ELEMENT_NODE : 1,
    TEXT_NODE : 3,

    BACKSPACE_KEY : 8,
    ENTER_KEY : 13,
    ESCAPE_KEY : 27,
    SPACE_KEY : 32,
    DELETE_KEY : 46,
    TAB_KEY : 9,
    BLOCK_ELEMENTS_GROUP : ["H1", "H2", "H3", "H4", "H5", "H6", "P"]
};
/**
 * @license Rangy, a cross-browser JavaScript range and selection library
 * http://code.google.com/p/rangy/
 *
 * Copyright 2011, Tim Down
 * Licensed under the MIT license.
 * Version: 1.2.2
 * Build date: 13 November 2011
 */
window.rangy = (function () {

    var OBJECT = "object", FUNCTION = "function", UNDEFINED = "undefined";

    var domRangeProperties = ["startContainer", "startOffset", "endContainer", "endOffset", "collapsed",
        "commonAncestorContainer", "START_TO_START", "START_TO_END", "END_TO_START", "END_TO_END"];

    var domRangeMethods = ["setStart", "setStartBefore", "setStartAfter", "setEnd", "setEndBefore",
        "setEndAfter", "collapse", "selectNode", "selectNodeContents", "compareBoundaryPoints", "deleteContents",
        "extractContents", "cloneContents", "insertNode", "surroundContents", "cloneRange", "toString", "detach"];

    var textRangeProperties = ["boundingHeight", "boundingLeft", "boundingTop", "boundingWidth", "htmlText", "text"];

    // Subset of TextRange's full set of methods that we're interested in
    var textRangeMethods = ["collapse", "compareEndPoints", "duplicate", "getBookmark", "moveToBookmark",
        "moveToElementText", "parentElement", "pasteHTML", "select", "setEndPoint", "getBoundingClientRect"];

    /*----------------------------------------------------------------------------------------------------------------*/

    // Trio of functions taken from Peter Michaux's article:
    // http://peter.michaux.ca/articles/feature-detection-state-of-the-art-browser-scripting
    function isHostMethod(o, p) {
        var t = typeof o[p];
        return t == FUNCTION || (!!(t == OBJECT && o[p])) || t == "unknown";
    }

    function isHostObject(o, p) {
        return !!(typeof o[p] == OBJECT && o[p]);
    }

    function isHostProperty(o, p) {
        return typeof o[p] != UNDEFINED;
    }

    // Creates a convenience function to save verbose repeated calls to tests functions
    function createMultiplePropertyTest(testFunc) {
        return function (o, props) {
            var i = props.length;
            while (i--) {
                if (!testFunc(o, props[i])) {
                    return false;
                }
            }
            return true;
        };
    }

    // Next trio of functions are a convenience to save verbose repeated calls to previous two functions
    var areHostMethods = createMultiplePropertyTest(isHostMethod);
    var areHostObjects = createMultiplePropertyTest(isHostObject);
    var areHostProperties = createMultiplePropertyTest(isHostProperty);

    function isTextRange(range) {
        return range && areHostMethods(range, textRangeMethods) && areHostProperties(range, textRangeProperties);
    }

    var api = {
        version : "1.2.2",
        initialized : false,
        supported : true,

        util : {
            isHostMethod : isHostMethod,
            isHostObject : isHostObject,
            isHostProperty : isHostProperty,
            areHostMethods : areHostMethods,
            areHostObjects : areHostObjects,
            areHostProperties : areHostProperties,
            isTextRange : isTextRange
        },

        features : {},

        modules : {},
        config : {
            alertOnWarn : false,
            preferTextRange : false
        }
    };

    function fail(reason) {
        window.alert("Rangy not supported in your browser. Reason: " + reason);
        api.initialized = true;
        api.supported = false;
    }

    api.fail = fail;

    function warn(msg) {
        var warningMessage = "Rangy warning: " + msg;
        if (api.config.alertOnWarn) {
            window.alert(warningMessage);
        } else if (typeof window.console != UNDEFINED && typeof window.console.log != UNDEFINED) {
            window.console.log(warningMessage);
        }
    }

    api.warn = warn;

    if ({}.hasOwnProperty) {
        api.util.extend = function (o, props) {
            for (var i in props) {
                if (props.hasOwnProperty(i)) {
                    o[i] = props[i];
                }
            }
        };
    } else {
        fail("hasOwnProperty not supported");
    }

    var initListeners = [];
    var moduleInitializers = [];

    // Initialization
    function init() {
        if (api.initialized) {
            return;
        }
        var testRange;
        var implementsDomRange = false, implementsTextRange = false;

        // First, perform basic feature tests

        if (isHostMethod(document, "createRange")) {
            testRange = document.createRange();
            if (areHostMethods(testRange, domRangeMethods) && areHostProperties(testRange, domRangeProperties)) {
                implementsDomRange = true;
            }
            testRange.detach();
        }

        var body = isHostObject(document, "body") ? document.body : document.getElementsByTagName("body")[0];

        /* In case createRange is supported skipping validation for createTextRange API
         * as its not used in such scenario as well as reduces performance(CQ-4228166)  */
        if (!implementsDomRange && body && isHostMethod(body, "createTextRange")) {
            testRange = body.createTextRange();
            if (isTextRange(testRange)) {
                implementsTextRange = true;
            }
        }

        if (!implementsDomRange && !implementsTextRange) {
            fail("Neither Range nor TextRange are implemented");
        }

        api.initialized = true;
        api.features = {
            implementsDomRange : implementsDomRange,
            implementsTextRange : implementsTextRange
        };

        // Initialize modules and call init listeners
        var allListeners = moduleInitializers.concat(initListeners);
        for (var i = 0, len = allListeners.length;
             i < len;
             ++i) {
            try {
                allListeners[i](api);
            } catch (ex) {
                if (isHostObject(window, "console") && isHostMethod(window.console, "log")) {
                    window.console.log("Init listener threw an exception. Continuing.", ex);
                }
            }
        }
    }

    // Allow external scripts to initialize this library in case it's loaded after the document has loaded
    api.init = init;

    // Execute listener immediately if already initialized
    api.addInitListener = function (listener) {
        if (api.initialized) {
            listener(api);
        } else {
            initListeners.push(listener);
        }
    };

    var createMissingNativeApiListeners = [];

    api.addCreateMissingNativeApiListener = function (listener) {
        createMissingNativeApiListeners.push(listener);
    };

    function createMissingNativeApi(win) {
        win = win || window;
        init();

        // Notify listeners
        for (var i = 0, len = createMissingNativeApiListeners.length;
             i < len;
             ++i) {
            createMissingNativeApiListeners[i](win);
        }
    }

    api.createMissingNativeApi = createMissingNativeApi;

    /**
     * @constructor
     */
    function Module(name) {
        this.name = name;
        this.initialized = false;
        this.supported = false;
    }

    Module.prototype.fail = function (reason) {
        this.initialized = true;
        this.supported = false;

        throw new Error("Module '" + this.name + "' failed to load: " + reason);
    };

    Module.prototype.warn = function (msg) {
        api.warn("Module " + this.name + ": " + msg);
    };

    Module.prototype.createError = function (msg) {
        return new Error("Error in Rangy " + this.name + " module: " + msg);
    };

    api.createModule = function (name, initFunc) {
        var module = new Module(name);
        api.modules[name] = module;

        moduleInitializers.push(function (api) {
            initFunc(api, module);
            module.initialized = true;
            module.supported = true;
        });
    };

    api.requireModules = function (modules) {
        for (var i = 0, len = modules.length, module, moduleName;
             i < len;
             ++i) {
            moduleName = modules[i];
            module = api.modules[moduleName];
            if (!module || !(module instanceof Module)) {
                throw new Error("Module '" + moduleName + "' not found");
            }
            if (!module.supported) {
                throw new Error("Module '" + moduleName + "' not supported");
            }
        }
    };

    /*----------------------------------------------------------------------------------------------------------------*/

    // Wait for document to load before running tests

    var docReady = false;

    var loadHandler = function (e) {

        if (!docReady) {
            docReady = true;
            if (!api.initialized) {
                init();
            }
        }
    };

    // Test whether we have window and document objects that we will need
    if (typeof window == UNDEFINED) {
        fail("No window found");
        return;
    }
    if (typeof document == UNDEFINED) {
        fail("No document found");
        return;
    }

    if (isHostMethod(document, "addEventListener")) {
        document.addEventListener("DOMContentLoaded", loadHandler, false);
    }

    // Add a fallback in case the DOMContentLoaded event isn't supported
    if (isHostMethod(window, "addEventListener")) {
        window.addEventListener("load", loadHandler, false);
    } else if (isHostMethod(window, "attachEvent")) {
        window.attachEvent("onload", loadHandler);
    } else {
        fail("Window does not have required addEventListener or attachEvent method");
    }

    return api;
})();
rangy.createModule("DomUtil", function (api, module) {

    var UNDEF = "undefined";
    var util = api.util;

    // Perform feature tests
    if (!util.areHostMethods(document, ["createDocumentFragment", "createElement", "createTextNode"])) {
        module.fail("document missing a Node creation method");
    }

    if (!util.isHostMethod(document, "getElementsByTagName")) {
        module.fail("document missing getElementsByTagName method");
    }

    var el = document.createElement("div");
    if (!util.areHostMethods(el, ["insertBefore", "appendChild", "cloneNode"] || !util.areHostObjects(el, ["previousSibling", "nextSibling", "childNodes", "parentNode"]))) {
        module.fail("Incomplete Element implementation");
    }

    // innerHTML is required for Range's createContextualFragment method
    if (!util.isHostProperty(el, "innerHTML")) {
        module.fail("Element is missing innerHTML property");
    }

    var textNode = document.createTextNode("test");
    if (!util.areHostMethods(textNode, ["splitText", "deleteData", "insertData", "appendData", "cloneNode"] || !util.areHostObjects(el, ["previousSibling", "nextSibling", "childNodes", "parentNode"]) || !util.areHostProperties(textNode, ["data"]))) {
        module.fail("Incomplete Text Node implementation");
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    // Removed use of indexOf because of a bizarre bug in Opera that is thrown in one of the Acid3 tests. I haven't been
    // able to replicate it outside of the test. The bug is that indexOf returns -1 when called on an Array that
    // contains just the document as a single element and the value searched for is the document.
    var arrayContains = /*Array.prototype.indexOf ?
     function(arr, val) {
     return arr.indexOf(val) > -1;
     }:*/

        function (arr, val) {
            var i = arr.length;
            while (i--) {
                if (arr[i] === val) {
                    return true;
                }
            }
            return false;
        };

    // Opera 11 puts HTML elements in the null namespace, it seems, and IE 7 has undefined namespaceURI
    function isHtmlNamespace(node) {
        var ns;
        return typeof node.namespaceURI == UNDEF || ((ns = node.namespaceURI) === null || ns == "http://www.w3.org/1999/xhtml");
    }

    function parentElement(node) {
        var parent = node.parentNode;
        return (parent.nodeType == 1) ? parent : null;
    }

    function getNodeIndex(node) {
        var i = 0;
        while ((node = node.previousSibling)) {
            i++;
        }
        return i;
    }

    function getNodeLength(node) {
        var childNodes;
        return isCharacterDataNode(node) ? node.length : ((childNodes = node.childNodes) ? childNodes.length : 0);
    }

    function getCommonAncestor(node1, node2) {
        var ancestors = [], n;
        for (n = node1;
             n;
             n = n.parentNode) {
            ancestors.push(n);
        }

        for (n = node2;
             n;
             n = n.parentNode) {
            if (arrayContains(ancestors, n)) {
                return n;
            }
        }

        return null;
    }

    function isAncestorOf(ancestor, descendant, selfIsAncestor) {
        var n = selfIsAncestor ? descendant : descendant.parentNode;
        while (n) {
            if (n === ancestor) {
                return true;
            } else {
                n = n.parentNode;
            }
        }
        return false;
    }

    function getClosestAncestorIn(node, ancestor, selfIsAncestor) {
        var p, n = selfIsAncestor ? node : node.parentNode;
        while (n) {
            p = n.parentNode;
            if (p === ancestor) {
                return n;
            }
            n = p;
        }
        return null;
    }

    function isCharacterDataNode(node) {
        var t = node.nodeType;
        return t == 3 || t == 4 || t == 8; // Text, CDataSection or Comment
    }

    function insertAfter(node, precedingNode) {
        var nextNode = precedingNode.nextSibling, parent = precedingNode.parentNode;
        if (nextNode) {
            parent.insertBefore(node, nextNode);
        } else {
            parent.appendChild(node);
        }
        return node;
    }

    // Note that we cannot use splitText() because it is bugridden in IE 9.
    function splitDataNode(node, index) {
        var newNode = node.cloneNode(false);
        newNode.deleteData(0, index);
        node.deleteData(index, node.length - index);
        insertAfter(newNode, node);
        return newNode;
    }

    function getDocument(node) {
        if (node.nodeType == 9) {
            return node;
        } else if (typeof node.ownerDocument != UNDEF) {
            return node.ownerDocument;
        } else if (typeof node.document != UNDEF) {
            return node.document;
        } else if (node.parentNode) {
            return getDocument(node.parentNode);
        } else {
            throw new Error("getDocument: no document found for node");
        }
    }

    function getWindow(node) {
        var doc = getDocument(node);
        if (typeof doc.defaultView != UNDEF) {
            return doc.defaultView;
        } else if (typeof doc.parentWindow != UNDEF) {
            return doc.parentWindow;
        } else {
            throw new Error("Cannot get a window object for node");
        }
    }

    function getIframeDocument(iframeEl) {
        if (typeof iframeEl.contentDocument != UNDEF) {
            return iframeEl.contentDocument;
        } else if (typeof iframeEl.contentWindow != UNDEF) {
            return iframeEl.contentWindow.document;
        } else {
            throw new Error("getIframeWindow: No Document object found for iframe element");
        }
    }

    function getIframeWindow(iframeEl) {
        if (typeof iframeEl.contentWindow != UNDEF) {
            return iframeEl.contentWindow;
        } else if (typeof iframeEl.contentDocument != UNDEF) {
            return iframeEl.contentDocument.defaultView;
        } else {
            throw new Error("getIframeWindow: No Window object found for iframe element");
        }
    }

    function getBody(doc) {
        return util.isHostObject(doc, "body") ? doc.body : doc.getElementsByTagName("body")[0];
    }

    function getRootContainer(node) {
        var parent;
        while ((parent = node.parentNode)) {
            node = parent;
        }
        return node;
    }

    function comparePoints(nodeA, offsetA, nodeB, offsetB) {
        // See http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Comparing
        var nodeC, root, childA, childB, n;
        if (nodeA == nodeB) {

            // Case 1: nodes are the same
            return offsetA === offsetB ? 0 : (offsetA < offsetB) ? -1 : 1;
        } else if ((nodeC = getClosestAncestorIn(nodeB, nodeA, true))) {

            // Case 2: node C (container B or an ancestor) is a child node of A
            return offsetA <= getNodeIndex(nodeC) ? -1 : 1;
        } else if ((nodeC = getClosestAncestorIn(nodeA, nodeB, true))) {

            // Case 3: node C (container A or an ancestor) is a child node of B
            return getNodeIndex(nodeC) < offsetB ? -1 : 1;
        } else {

            // Case 4: containers are siblings or descendants of siblings
            root = getCommonAncestor(nodeA, nodeB);
            childA = (nodeA === root) ? root : getClosestAncestorIn(nodeA, root, true);
            childB = (nodeB === root) ? root : getClosestAncestorIn(nodeB, root, true);

            if (childA === childB) {
                // This shouldn't be possible

                throw new Error("comparePoints got to case 4 and childA and childB are the same!");
            } else {
                n = root.firstChild;
                while (n) {
                    if (n === childA) {
                        return -1;
                    } else if (n === childB) {
                        return 1;
                    }
                    n = n.nextSibling;
                }
                throw new Error("Should not be here!");
            }
        }
    }

    function fragmentFromNodeChildren(node) {
        var fragment = getDocument(node).createDocumentFragment(), child;
        while ((child = node.firstChild)) {
            fragment.appendChild(child);
        }
        return fragment;
    }

    function inspectNode(node) {
        if (!node) {
            return "[No node]";
        }
        if (isCharacterDataNode(node)) {
            return '"' + node.data + '"';
        } else if (node.nodeType == 1) {
            var idAttr = node.id ? ' id="' + node.id + '"' : "";
            return "<" + node.nodeName + idAttr + ">[" + node.childNodes.length + "]";
        } else {
            return node.nodeName;
        }
    }

    /**
     * @constructor
     */
    function NodeIterator(root) {
        this.root = root;
        this._next = root;
    }

    NodeIterator.prototype = {
        _current : null,

        hasNext : function () {
            return !!this._next;
        },

        next : function () {
            var n = this._current = this._next;
            var child, next;
            if (this._current) {
                child = n.firstChild;
                if (child) {
                    this._next = child;
                } else {
                    next = null;
                    while ((n !== this.root) && !(next = n.nextSibling)) {
                        n = n.parentNode;
                    }
                    this._next = next;
                }
            }
            return this._current;
        },

        detach : function () {
            this._current = this._next = this.root = null;
        }
    };

    function createIterator(root) {
        return new NodeIterator(root);
    }

    /**
     * @constructor
     */
    function DomPosition(node, offset) {
        this.node = node;
        this.offset = offset;
    }

    DomPosition.prototype = {
        equals : function (pos) {
            return this.node === pos.node & this.offset == pos.offset;
        },

        inspect : function () {
            return "[DomPosition(" + inspectNode(this.node) + ":" + this.offset + ")]";
        }
    };

    /**
     * @constructor
     */
    function DOMException(codeName) {
        this.code = this[codeName];
        this.codeName = codeName;
        this.message = "DOMException: " + this.codeName;
    }

    DOMException.prototype = {
        INDEX_SIZE_ERR : 1,
        HIERARCHY_REQUEST_ERR : 3,
        WRONG_DOCUMENT_ERR : 4,
        NO_MODIFICATION_ALLOWED_ERR : 7,
        NOT_FOUND_ERR : 8,
        NOT_SUPPORTED_ERR : 9,
        INVALID_STATE_ERR : 11
    };

    DOMException.prototype.toString = function () {
        return this.message;
    };

    api.dom = {
        arrayContains : arrayContains,
        isHtmlNamespace : isHtmlNamespace,
        parentElement : parentElement,
        getNodeIndex : getNodeIndex,
        getNodeLength : getNodeLength,
        getCommonAncestor : getCommonAncestor,
        isAncestorOf : isAncestorOf,
        getClosestAncestorIn : getClosestAncestorIn,
        isCharacterDataNode : isCharacterDataNode,
        insertAfter : insertAfter,
        splitDataNode : splitDataNode,
        getDocument : getDocument,
        getWindow : getWindow,
        getIframeWindow : getIframeWindow,
        getIframeDocument : getIframeDocument,
        getBody : getBody,
        getRootContainer : getRootContainer,
        comparePoints : comparePoints,
        inspectNode : inspectNode,
        fragmentFromNodeChildren : fragmentFromNodeChildren,
        createIterator : createIterator,
        DomPosition : DomPosition
    };

    api.DOMException = DOMException;
});
rangy.createModule("DomRange", function (api, module) {
    api.requireModules(["DomUtil"]);

    var dom = api.dom;
    var DomPosition = dom.DomPosition;
    var DOMException = api.DOMException;

    /*----------------------------------------------------------------------------------------------------------------*/

    // Utility functions

    function isNonTextPartiallySelected(node, range) {
        return (node.nodeType != 3) && (dom.isAncestorOf(node, range.startContainer, true) || dom.isAncestorOf(node, range.endContainer, true));
    }

    function getRangeDocument(range) {
        return dom.getDocument(range.startContainer);
    }

    function dispatchEvent(range, type, args) {
        var listeners = range._listeners[type];
        if (listeners) {
            for (var i = 0, len = listeners.length;
                 i < len;
                 ++i) {
                listeners[i].call(range, {target : range, args : args});
            }
        }
    }

    function getBoundaryBeforeNode(node) {
        return new DomPosition(node.parentNode, dom.getNodeIndex(node));
    }

    function getBoundaryAfterNode(node) {
        return new DomPosition(node.parentNode, dom.getNodeIndex(node) + 1);
    }

    function insertNodeAtPosition(node, n, o) {
        var firstNodeInserted = node.nodeType == 11 ? node.firstChild : node;
        if (dom.isCharacterDataNode(n)) {
            if (o == n.length) {
                dom.insertAfter(node, n);
            } else {
                n.parentNode.insertBefore(node, o == 0 ? n : dom.splitDataNode(n, o));
            }
        } else if (o >= n.childNodes.length) {
            n.appendChild(node);
        } else {
            n.insertBefore(node, n.childNodes[o]);
        }
        return firstNodeInserted;
    }

    function cloneSubtree(iterator) {
        var partiallySelected;
        for (var node, frag = getRangeDocument(iterator.range).createDocumentFragment(), subIterator;
             node = iterator.next();) {
            partiallySelected = iterator.isPartiallySelectedSubtree();

            node = node.cloneNode(!partiallySelected);
            if (partiallySelected) {
                subIterator = iterator.getSubtreeIterator();
                node.appendChild(cloneSubtree(subIterator));
                subIterator.detach(true);
            }

            if (node.nodeType == 10) {// DocumentType
                throw new DOMException("HIERARCHY_REQUEST_ERR");
            }
            frag.appendChild(node);
        }
        return frag;
    }

    function iterateSubtree(rangeIterator, func, iteratorState) {
        var it, n;
        iteratorState = iteratorState || {stop : false};
        for (var node, subRangeIterator;
             node = rangeIterator.next();) {
            //log.debug("iterateSubtree, partially selected: " + rangeIterator.isPartiallySelectedSubtree(), nodeToString(node));
            if (rangeIterator.isPartiallySelectedSubtree()) {
                // The node is partially selected by the Range, so we can use a new RangeIterator on the portion of the
                // node selected by the Range.
                if (func(node) === false) {
                    iteratorState.stop = true;
                    return;
                } else {
                    subRangeIterator = rangeIterator.getSubtreeIterator();
                    iterateSubtree(subRangeIterator, func, iteratorState);
                    subRangeIterator.detach(true);
                    if (iteratorState.stop) {
                        return;
                    }
                }
            } else {
                // The whole node is selected, so we can use efficient DOM iteration to iterate over the node and its
                // descendant
                it = dom.createIterator(node);
                while ((n = it.next())) {
                    if (func(n) === false) {
                        iteratorState.stop = true;
                        return;
                    }
                }
            }
        }
    }

    function deleteSubtree(iterator) {
        var subIterator;
        while (iterator.next()) {
            if (iterator.isPartiallySelectedSubtree()) {
                subIterator = iterator.getSubtreeIterator();
                deleteSubtree(subIterator);
                subIterator.detach(true);
            } else {
                iterator.remove();
            }
        }
    }

    function extractSubtree(iterator) {

        for (var node, frag = getRangeDocument(iterator.range).createDocumentFragment(), subIterator;
             node = iterator.next();) {

            if (iterator.isPartiallySelectedSubtree()) {
                node = node.cloneNode(false);
                subIterator = iterator.getSubtreeIterator();
                node.appendChild(extractSubtree(subIterator));
                subIterator.detach(true);
            } else {
                iterator.remove();
            }
            if (node.nodeType == 10) {// DocumentType
                throw new DOMException("HIERARCHY_REQUEST_ERR");
            }
            frag.appendChild(node);
        }
        return frag;
    }

    function getNodesInRange(range, nodeTypes, filter) {
        //log.info("getNodesInRange, " + nodeTypes.join(","));
        var filterNodeTypes = !!(nodeTypes && nodeTypes.length), regex;
        var filterExists = !!filter;
        if (filterNodeTypes) {
            regex = new RegExp("^(" + nodeTypes.join("|") + ")$");
        }

        var nodes = [];
        iterateSubtree(new RangeIterator(range, false), function (node) {
            if ((!filterNodeTypes || regex.test(node.nodeType)) && (!filterExists || filter(node))) {
                nodes.push(node);
            }
        });
        return nodes;
    }

    function inspect(range) {
        var name = (typeof range.getName == "undefined") ? "Range" : range.getName();
        return "[" + name + "(" + dom.inspectNode(range.startContainer) + ":" + range.startOffset + ", " +
            dom.inspectNode(range.endContainer) + ":" + range.endOffset + ")]";
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    // RangeIterator code partially borrows from IERange by Tim Ryan (http://github.com/timcameronryan/IERange)

    /**
     * @constructor
     */
    function RangeIterator(range, clonePartiallySelectedTextNodes) {
        this.range = range;
        this.clonePartiallySelectedTextNodes = clonePartiallySelectedTextNodes;

        if (!range.collapsed) {
            this.sc = range.startContainer;
            this.so = range.startOffset;
            this.ec = range.endContainer;
            this.eo = range.endOffset;
            var root = range.commonAncestorContainer;

            if (this.sc === this.ec && dom.isCharacterDataNode(this.sc)) {
                this.isSingleCharacterDataNode = true;
                this._first = this._last = this._next = this.sc;
            } else {
                this._first = this._next = (this.sc === root && !dom.isCharacterDataNode(this.sc)) ?
                    this.sc.childNodes[this.so] : dom.getClosestAncestorIn(this.sc, root, true);
                this._last = (this.ec === root && !dom.isCharacterDataNode(this.ec)) ?
                    this.ec.childNodes[this.eo - 1] : dom.getClosestAncestorIn(this.ec, root, true);
            }
        }
    }

    RangeIterator.prototype = {
        _current : null,
        _next : null,
        _first : null,
        _last : null,
        isSingleCharacterDataNode : false,

        reset : function () {
            this._current = null;
            this._next = this._first;
        },

        hasNext : function () {
            return !!this._next;
        },

        next : function () {
            // Move to next node
            var current = this._current = this._next;
            if (current) {
                this._next = (current !== this._last) ? current.nextSibling : null;

                // Check for partially selected text nodes
                if (dom.isCharacterDataNode(current) && this.clonePartiallySelectedTextNodes) {
                    if (current === this.ec) {

                        (current = current.cloneNode(true)).deleteData(this.eo, current.length - this.eo);
                    }
                    if (this._current === this.sc) {

                        (current = current.cloneNode(true)).deleteData(0, this.so);
                    }
                }
            }

            return current;
        },

        remove : function () {
            var current = this._current, start, end;

            if (dom.isCharacterDataNode(current) && (current === this.sc || current === this.ec)) {
                start = (current === this.sc) ? this.so : 0;
                end = (current === this.ec) ? this.eo : current.length;
                if (start != end) {
                    current.deleteData(start, end - start);
                }
            } else {
                if (current.parentNode) {
                    current.parentNode.removeChild(current);
                } else {
                }
            }
        },

        // Checks if the current node is partially selected
        isPartiallySelectedSubtree : function () {
            var current = this._current;
            return isNonTextPartiallySelected(current, this.range);
        },

        getSubtreeIterator : function () {
            var subRange;
            if (this.isSingleCharacterDataNode) {
                subRange = this.range.cloneRange();
                subRange.collapse();
            } else {
                subRange = new Range(getRangeDocument(this.range));
                var current = this._current;
                var startContainer = current, startOffset = 0, endContainer = current,
                    endOffset = dom.getNodeLength(current);

                if (dom.isAncestorOf(current, this.sc, true)) {
                    startContainer = this.sc;
                    startOffset = this.so;
                }
                if (dom.isAncestorOf(current, this.ec, true)) {
                    endContainer = this.ec;
                    endOffset = this.eo;
                }

                updateBoundaries(subRange, startContainer, startOffset, endContainer, endOffset);
            }
            return new RangeIterator(subRange, this.clonePartiallySelectedTextNodes);
        },

        detach : function (detachRange) {
            if (detachRange) {
                this.range.detach();
            }
            this.range = this._current = this._next = this._first = this._last = this.sc = this.so = this.ec = this.eo = null;
        }
    };

    /*----------------------------------------------------------------------------------------------------------------*/

    // Exceptions

    /**
     * @constructor
     */
    function RangeException(codeName) {
        this.code = this[codeName];
        this.codeName = codeName;
        this.message = "RangeException: " + this.codeName;
    }

    RangeException.prototype = {
        BAD_BOUNDARYPOINTS_ERR : 1,
        INVALID_NODE_TYPE_ERR : 2
    };

    RangeException.prototype.toString = function () {
        return this.message;
    };

    /*----------------------------------------------------------------------------------------------------------------*/

    /**
     * Currently iterates through all nodes in the range on creation until I think of a decent way to do it
     * TODO: Look into making this a proper iterator, not requiring preloading everything first
     * @constructor
     */
    function RangeNodeIterator(range, nodeTypes, filter) {
        this.nodes = getNodesInRange(range, nodeTypes, filter);
        this._next = this.nodes[0];
        this._position = 0;
    }

    RangeNodeIterator.prototype = {
        _current : null,

        hasNext : function () {
            return !!this._next;
        },

        next : function () {
            this._current = this._next;
            this._next = this.nodes[++this._position];
            return this._current;
        },

        detach : function () {
            this._current = this._next = this.nodes = null;
        }
    };

    var beforeAfterNodeTypes = [1, 3, 4, 5, 7, 8, 10];
    var rootContainerNodeTypes = [2, 9, 11];
    var readonlyNodeTypes = [5, 6, 10, 12];
    var insertableNodeTypes = [1, 3, 4, 5, 7, 8, 10, 11];
    var surroundNodeTypes = [1, 3, 4, 5, 7, 8];

    function createAncestorFinder(nodeTypes) {
        return function (node, selfIsAncestor) {
            var t, n = selfIsAncestor ? node : node.parentNode;
            while (n) {
                t = n.nodeType;
                if (dom.arrayContains(nodeTypes, t)) {
                    return n;
                }
                n = n.parentNode;
            }
            return null;
        };
    }

    var getRootContainer = dom.getRootContainer;
    var getDocumentOrFragmentContainer = createAncestorFinder([9, 11]);
    var getReadonlyAncestor = createAncestorFinder(readonlyNodeTypes);
    var getDocTypeNotationEntityAncestor = createAncestorFinder([6, 10, 12]);

    function assertNoDocTypeNotationEntityAncestor(node, allowSelf) {
        if (getDocTypeNotationEntityAncestor(node, allowSelf)) {
            throw new RangeException("INVALID_NODE_TYPE_ERR");
        }
    }

    function assertNotDetached(range) {
        if (!range.startContainer) {
            throw new DOMException("INVALID_STATE_ERR");
        }
    }

    function assertValidNodeType(node, invalidTypes) {
        if (!dom.arrayContains(invalidTypes, node.nodeType)) {
            throw new RangeException("INVALID_NODE_TYPE_ERR");
        }
    }

    function assertValidOffset(node, offset) {
        if (offset < 0 || offset > (dom.isCharacterDataNode(node) ? node.length : node.childNodes.length)) {
            throw new DOMException("INDEX_SIZE_ERR");
        }
    }

    function assertSameDocumentOrFragment(node1, node2) {
        if (getDocumentOrFragmentContainer(node1, true) !== getDocumentOrFragmentContainer(node2, true)) {
            throw new DOMException("WRONG_DOCUMENT_ERR");
        }
    }

    function assertNodeNotReadOnly(node) {
        if (getReadonlyAncestor(node, true)) {
            throw new DOMException("NO_MODIFICATION_ALLOWED_ERR");
        }
    }

    function assertNode(node, codeName) {
        if (!node) {
            throw new DOMException(codeName);
        }
    }

    function isOrphan(node) {
        return !dom.arrayContains(rootContainerNodeTypes, node.nodeType) && !getDocumentOrFragmentContainer(node, true);
    }

    function isValidOffset(node, offset) {
        return offset <= (dom.isCharacterDataNode(node) ? node.length : node.childNodes.length);
    }

    function assertRangeValid(range) {
        assertNotDetached(range);
        if (isOrphan(range.startContainer) || isOrphan(range.endContainer) || !isValidOffset(range.startContainer, range.startOffset) || !isValidOffset(range.endContainer, range.endOffset)) {
            throw new Error("Range error: Range is no longer valid after DOM mutation (" + range.inspect() + ")");
        }
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    // Test the browser's innerHTML support to decide how to implement createContextualFragment
    var styleEl = document.createElement("style");
    var htmlParsingConforms = false;
    try {
        styleEl.innerHTML = "<b>x</b>";
        htmlParsingConforms = (styleEl.firstChild.nodeType == 3); // Opera incorrectly creates an element node
    } catch (e) {
        // IE 6 and 7 throw
    }

    api.features.htmlParsingConforms = htmlParsingConforms;

    var createContextualFragment = htmlParsingConforms ?

        // Implementation as per HTML parsing spec, trusting in the browser's implementation of innerHTML. See
        // discussion and base code for this implementation at issue 67.
        // Spec: http://html5.org/specs/dom-parsing.html#extensions-to-the-range-interface
        // Thanks to Aleks Williams.
        function (fragmentStr) {
            // "Let node the context object's start's node."
            var node = this.startContainer;
            var doc = dom.getDocument(node);

            // "If the context object's start's node is null, raise an INVALID_STATE_ERR
            // exception and abort these steps."
            if (!node) {
                throw new DOMException("INVALID_STATE_ERR");
            }

            // "Let element be as follows, depending on node's interface:"
            // Document, Document Fragment: null
            var el = null;

            // "Element: node"
            if (node.nodeType == 1) {
                el = node;

                // "Text, Comment: node's parentElement"
            } else if (dom.isCharacterDataNode(node)) {
                el = dom.parentElement(node);
            }

            // "If either element is null or element's ownerDocument is an HTML document
            // and element's local name is "html" and element's namespace is the HTML
            // namespace"
            if (el === null || (
                    el.nodeName == "HTML" && dom.isHtmlNamespace(dom.getDocument(el).documentElement) && dom.isHtmlNamespace(el)
                )) {

                // "let element be a new Element with "body" as its local name and the HTML
                // namespace as its namespace.""
                el = doc.createElement("body");
            } else {
                el = el.cloneNode(false);
            }

            // "If the node's document is an HTML document: Invoke the HTML fragment parsing algorithm."
            // "If the node's document is an XML document: Invoke the XML fragment parsing algorithm."
            // "In either case, the algorithm must be invoked with fragment as the input
            // and element as the context element."
            el.innerHTML = fragmentStr;

            // "If this raises an exception, then abort these steps. Otherwise, let new
            // children be the nodes returned."

            // "Let fragment be a new DocumentFragment."
            // "Append all new children to fragment."
            // "Return fragment."
            return dom.fragmentFromNodeChildren(el);
        } :

        // In this case, innerHTML cannot be trusted, so fall back to a simpler, non-conformant implementation that
        // previous versions of Rangy used (with the exception of using a body element rather than a div)
        function (fragmentStr) {
            assertNotDetached(this);
            var doc = getRangeDocument(this);
            var el = doc.createElement("body");
            el.innerHTML = fragmentStr;

            return dom.fragmentFromNodeChildren(el);
        };

    /*----------------------------------------------------------------------------------------------------------------*/

    var rangeProperties = ["startContainer", "startOffset", "endContainer", "endOffset", "collapsed",
        "commonAncestorContainer"];

    var s2s = 0, s2e = 1, e2e = 2, e2s = 3;
    var n_b = 0, n_a = 1, n_b_a = 2, n_i = 3;

    function RangePrototype() {
    }

    RangePrototype.prototype = {
        attachListener : function (type, listener) {
            this._listeners[type].push(listener);
        },

        compareBoundaryPoints : function (how, range) {
            assertRangeValid(this);
            assertSameDocumentOrFragment(this.startContainer, range.startContainer);

            var nodeA, offsetA, nodeB, offsetB;
            var prefixA = (how == e2s || how == s2s) ? "start" : "end";
            var prefixB = (how == s2e || how == s2s) ? "start" : "end";
            nodeA = this[prefixA + "Container"];
            offsetA = this[prefixA + "Offset"];
            nodeB = range[prefixB + "Container"];
            offsetB = range[prefixB + "Offset"];
            return dom.comparePoints(nodeA, offsetA, nodeB, offsetB);
        },

        insertNode : function (node) {
            assertRangeValid(this);
            assertValidNodeType(node, insertableNodeTypes);
            assertNodeNotReadOnly(this.startContainer);

            if (dom.isAncestorOf(node, this.startContainer, true)) {
                throw new DOMException("HIERARCHY_REQUEST_ERR");
            }

            // No check for whether the container of the start of the Range is of a type that does not allow
            // children of the type of node: the browser's DOM implementation should do this for us when we attempt
            // to add the node

            var firstNodeInserted = insertNodeAtPosition(node, this.startContainer, this.startOffset);
            this.setStartBefore(firstNodeInserted);
        },

        cloneContents : function () {
            assertRangeValid(this);

            var clone, frag;
            if (this.collapsed) {
                return getRangeDocument(this).createDocumentFragment();
            } else {
                if (this.startContainer === this.endContainer && dom.isCharacterDataNode(this.startContainer)) {
                    clone = this.startContainer.cloneNode(true);
                    clone.data = clone.data.slice(this.startOffset, this.endOffset);
                    frag = getRangeDocument(this).createDocumentFragment();
                    frag.appendChild(clone);
                    return frag;
                } else {
                    var iterator = new RangeIterator(this, true);
                    clone = cloneSubtree(iterator);
                    iterator.detach();
                }
                return clone;
            }
        },

        canSurroundContents : function () {
            assertRangeValid(this);
            assertNodeNotReadOnly(this.startContainer);
            assertNodeNotReadOnly(this.endContainer);

            // Check if the contents can be surrounded. Specifically, this means whether the range partially selects
            // no non-text nodes.
            var iterator = new RangeIterator(this, true);
            var boundariesInvalid = (iterator._first && (isNonTextPartiallySelected(iterator._first, this)) ||
            (iterator._last && isNonTextPartiallySelected(iterator._last, this)));
            iterator.detach();
            return !boundariesInvalid;
        },

        surroundContents : function (node) {
            assertValidNodeType(node, surroundNodeTypes);

            if (!this.canSurroundContents()) {
                throw new RangeException("BAD_BOUNDARYPOINTS_ERR");
            }

            // Extract the contents
            var content = this.extractContents();

            // Clear the children of the node
            if (node.hasChildNodes()) {
                while (node.lastChild) {
                    node.removeChild(node.lastChild);
                }
            }

            // Insert the new node and add the extracted contents
            insertNodeAtPosition(node, this.startContainer, this.startOffset);
            node.appendChild(content);

            this.selectNode(node);
        },

        cloneRange : function () {
            assertRangeValid(this);
            var range = new Range(getRangeDocument(this));
            var i = rangeProperties.length, prop;
            while (i--) {
                prop = rangeProperties[i];
                range[prop] = this[prop];
            }
            return range;
        },

        toString : function () {
            assertRangeValid(this);
            var sc = this.startContainer;
            if (sc === this.endContainer && dom.isCharacterDataNode(sc)) {
                return (sc.nodeType == 3 || sc.nodeType == 4) ? sc.data.slice(this.startOffset, this.endOffset) : "";
            } else {
                var textBits = [], iterator = new RangeIterator(this, true);

                iterateSubtree(iterator, function (node) {
                    // Accept only text or CDATA nodes, not comments

                    if (node.nodeType == 3 || node.nodeType == 4) {
                        textBits.push(node.data);
                    }
                });
                iterator.detach();
                return textBits.join("");
            }
        },

        // The methods below are all non-standard. The following batch were introduced by Mozilla but have since
        // been removed from Mozilla.

        compareNode : function (node) {
            assertRangeValid(this);

            var parent = node.parentNode;
            var nodeIndex = dom.getNodeIndex(node);

            if (!parent) {
                throw new DOMException("NOT_FOUND_ERR");
            }

            var startComparison = this.comparePoint(parent, nodeIndex),
                endComparison = this.comparePoint(parent, nodeIndex + 1);

            if (startComparison < 0) {// Node starts before
                return (endComparison > 0) ? n_b_a : n_b;
            } else {
                return (endComparison > 0) ? n_a : n_i;
            }
        },

        comparePoint : function (node, offset) {
            assertRangeValid(this);
            assertNode(node, "HIERARCHY_REQUEST_ERR");
            assertSameDocumentOrFragment(node, this.startContainer);

            if (dom.comparePoints(node, offset, this.startContainer, this.startOffset) < 0) {
                return -1;
            } else if (dom.comparePoints(node, offset, this.endContainer, this.endOffset) > 0) {
                return 1;
            }
            return 0;
        },

        createContextualFragment : createContextualFragment,

        toHtml : function () {
            assertRangeValid(this);
            var container = getRangeDocument(this).createElement("div");
            container.appendChild(this.cloneContents());
            return container.innerHTML;
        },

        // touchingIsIntersecting determines whether this method considers a node that borders a range intersects
        // with it (as in WebKit) or not (as in Gecko pre-1.9, and the default)
        intersectsNode : function (node, touchingIsIntersecting) {
            assertRangeValid(this);
            assertNode(node, "NOT_FOUND_ERR");
            if (dom.getDocument(node) !== getRangeDocument(this)) {
                return false;
            }

            var parent = node.parentNode, offset = dom.getNodeIndex(node);
            assertNode(parent, "NOT_FOUND_ERR");

            var startComparison = dom.comparePoints(parent, offset, this.endContainer, this.endOffset),
                endComparison = dom.comparePoints(parent, offset + 1, this.startContainer, this.startOffset);

            return touchingIsIntersecting ? startComparison <= 0 && endComparison >= 0 : startComparison < 0 && endComparison > 0;
        },

        isPointInRange : function (node, offset) {
            assertRangeValid(this);
            assertNode(node, "HIERARCHY_REQUEST_ERR");
            assertSameDocumentOrFragment(node, this.startContainer);

            return (dom.comparePoints(node, offset, this.startContainer, this.startOffset) >= 0) && (dom.comparePoints(node, offset, this.endContainer, this.endOffset) <= 0);
        },

        // The methods below are non-standard and invented by me.

        // Sharing a boundary start-to-end or end-to-start does not count as intersection.
        intersectsRange : function (range, touchingIsIntersecting) {
            assertRangeValid(this);

            if (getRangeDocument(range) != getRangeDocument(this)) {
                throw new DOMException("WRONG_DOCUMENT_ERR");
            }

            var startComparison = dom.comparePoints(this.startContainer, this.startOffset, range.endContainer, range.endOffset),
                endComparison = dom.comparePoints(this.endContainer, this.endOffset, range.startContainer, range.startOffset);

            return touchingIsIntersecting ? startComparison <= 0 && endComparison >= 0 : startComparison < 0 && endComparison > 0;
        },

        intersection : function (range) {
            if (this.intersectsRange(range)) {
                var startComparison = dom.comparePoints(this.startContainer, this.startOffset, range.startContainer, range.startOffset),
                    endComparison = dom.comparePoints(this.endContainer, this.endOffset, range.endContainer, range.endOffset);

                var intersectionRange = this.cloneRange();

                if (startComparison == -1) {
                    intersectionRange.setStart(range.startContainer, range.startOffset);
                }
                if (endComparison == 1) {
                    intersectionRange.setEnd(range.endContainer, range.endOffset);
                }
                return intersectionRange;
            }
            return null;
        },

        union : function (range) {
            if (this.intersectsRange(range, true)) {
                var unionRange = this.cloneRange();
                if (dom.comparePoints(range.startContainer, range.startOffset, this.startContainer, this.startOffset) == -1) {
                    unionRange.setStart(range.startContainer, range.startOffset);
                }
                if (dom.comparePoints(range.endContainer, range.endOffset, this.endContainer, this.endOffset) == 1) {
                    unionRange.setEnd(range.endContainer, range.endOffset);
                }
                return unionRange;
            } else {
                throw new RangeException("Ranges do not intersect");
            }
        },

        containsNode : function (node, allowPartial) {
            if (allowPartial) {
                return this.intersectsNode(node, false);
            } else {
                return this.compareNode(node) == n_i;
            }
        },

        containsNodeContents : function (node) {
            return this.comparePoint(node, 0) >= 0 && this.comparePoint(node, dom.getNodeLength(node)) <= 0;
        },

        containsRange : function (range) {
            return this.intersection(range).equals(range);
        },

        containsNodeText : function (node) {
            var nodeRange = this.cloneRange();
            nodeRange.selectNode(node);
            var textNodes = nodeRange.getNodes([3]);
            if (textNodes.length > 0) {
                nodeRange.setStart(textNodes[0], 0);
                var lastTextNode = textNodes.pop();
                nodeRange.setEnd(lastTextNode, lastTextNode.length);
                var contains = this.containsRange(nodeRange);
                nodeRange.detach();
                return contains;
            } else {
                return this.containsNodeContents(node);
            }
        },

        createNodeIterator : function (nodeTypes, filter) {
            assertRangeValid(this);
            return new RangeNodeIterator(this, nodeTypes, filter);
        },

        getNodes : function (nodeTypes, filter) {
            assertRangeValid(this);
            return getNodesInRange(this, nodeTypes, filter);
        },

        getDocument : function () {
            return getRangeDocument(this);
        },

        collapseBefore : function (node) {
            assertNotDetached(this);

            this.setEndBefore(node);
            this.collapse(false);
        },

        collapseAfter : function (node) {
            assertNotDetached(this);

            this.setStartAfter(node);
            this.collapse(true);
        },

        getName : function () {
            return "DomRange";
        },

        equals : function (range) {
            return Range.rangesEqual(this, range);
        },

        inspect : function () {
            return inspect(this);
        }
    };

    function copyComparisonConstantsToObject(obj) {
        obj.START_TO_START = s2s;
        obj.START_TO_END = s2e;
        obj.END_TO_END = e2e;
        obj.END_TO_START = e2s;

        obj.NODE_BEFORE = n_b;
        obj.NODE_AFTER = n_a;
        obj.NODE_BEFORE_AND_AFTER = n_b_a;
        obj.NODE_INSIDE = n_i;
    }

    function copyComparisonConstants(constructor) {
        copyComparisonConstantsToObject(constructor);
        copyComparisonConstantsToObject(constructor.prototype);
    }

    function createRangeContentRemover(remover, boundaryUpdater) {
        return function () {
            assertRangeValid(this);

            var sc = this.startContainer, so = this.startOffset, root = this.commonAncestorContainer;

            var iterator = new RangeIterator(this, true);

            // Work out where to position the range after content removal
            var node, boundary;
            if (sc !== root) {
                node = dom.getClosestAncestorIn(sc, root, true);
                boundary = getBoundaryAfterNode(node);
                sc = boundary.node;
                so = boundary.offset;
            }

            // Check none of the range is read-only
            iterateSubtree(iterator, assertNodeNotReadOnly);

            iterator.reset();

            // Remove the content
            var returnValue = remover(iterator);
            iterator.detach();

            // Move to the new position
            boundaryUpdater(this, sc, so, sc, so);

            return returnValue;
        };
    }

    function createPrototypeRange(constructor, boundaryUpdater, detacher) {
        function createBeforeAfterNodeSetter(isBefore, isStart) {
            return function (node) {
                assertNotDetached(this);
                assertValidNodeType(node, beforeAfterNodeTypes);
                assertValidNodeType(getRootContainer(node), rootContainerNodeTypes);

                var boundary = (isBefore ? getBoundaryBeforeNode : getBoundaryAfterNode)(node);
                (isStart ? setRangeStart : setRangeEnd)(this, boundary.node, boundary.offset);
            };
        }

        function setRangeStart(range, node, offset) {
            var ec = range.endContainer, eo = range.endOffset;
            if (node !== range.startContainer || offset !== range.startOffset) {
                // Check the root containers of the range and the new boundary, and also check whether the new boundary
                // is after the current end. In either case, collapse the range to the new position
                if (getRootContainer(node) != getRootContainer(ec) || dom.comparePoints(node, offset, ec, eo) == 1) {
                    ec = node;
                    eo = offset;
                }
                boundaryUpdater(range, node, offset, ec, eo);
            }
        }

        function setRangeEnd(range, node, offset) {
            var sc = range.startContainer, so = range.startOffset;
            if (node !== range.endContainer || offset !== range.endOffset) {
                // Check the root containers of the range and the new boundary, and also check whether the new boundary
                // is after the current end. In either case, collapse the range to the new position
                if (getRootContainer(node) != getRootContainer(sc) || dom.comparePoints(node, offset, sc, so) == -1) {
                    sc = node;
                    so = offset;
                }
                boundaryUpdater(range, sc, so, node, offset);
            }
        }

        function setRangeStartAndEnd(range, node, offset) {
            if (node !== range.startContainer || offset !== range.startOffset || node !== range.endContainer || offset !== range.endOffset) {
                boundaryUpdater(range, node, offset, node, offset);
            }
        }

        constructor.prototype = new RangePrototype();

        api.util.extend(constructor.prototype, {
            setStart : function (node, offset) {
                assertNotDetached(this);
                assertNoDocTypeNotationEntityAncestor(node, true);
                assertValidOffset(node, offset);

                setRangeStart(this, node, offset);
            },

            setEnd : function (node, offset) {
                assertNotDetached(this);
                assertNoDocTypeNotationEntityAncestor(node, true);
                assertValidOffset(node, offset);

                setRangeEnd(this, node, offset);
            },

            setStartBefore : createBeforeAfterNodeSetter(true, true),
            setStartAfter : createBeforeAfterNodeSetter(false, true),
            setEndBefore : createBeforeAfterNodeSetter(true, false),
            setEndAfter : createBeforeAfterNodeSetter(false, false),

            collapse : function (isStart) {
                assertRangeValid(this);
                if (isStart) {
                    boundaryUpdater(this, this.startContainer, this.startOffset, this.startContainer, this.startOffset);
                } else {
                    boundaryUpdater(this, this.endContainer, this.endOffset, this.endContainer, this.endOffset);
                }
            },

            selectNodeContents : function (node) {
                // This doesn't seem well specified: the spec talks only about selecting the node's contents, which
                // could be taken to mean only its children. However, browsers implement this the same as selectNode for
                // text nodes, so I shall do likewise
                assertNotDetached(this);
                assertNoDocTypeNotationEntityAncestor(node, true);

                boundaryUpdater(this, node, 0, node, dom.getNodeLength(node));
            },

            selectNode : function (node) {
                assertNotDetached(this);
                assertNoDocTypeNotationEntityAncestor(node, false);
                assertValidNodeType(node, beforeAfterNodeTypes);

                var start = getBoundaryBeforeNode(node), end = getBoundaryAfterNode(node);
                boundaryUpdater(this, start.node, start.offset, end.node, end.offset);
            },

            extractContents : createRangeContentRemover(extractSubtree, boundaryUpdater),

            deleteContents : createRangeContentRemover(deleteSubtree, boundaryUpdater),

            canSurroundContents : function () {
                assertRangeValid(this);
                assertNodeNotReadOnly(this.startContainer);
                assertNodeNotReadOnly(this.endContainer);

                // Check if the contents can be surrounded. Specifically, this means whether the range partially selects
                // no non-text nodes.
                var iterator = new RangeIterator(this, true);
                var boundariesInvalid = (iterator._first && (isNonTextPartiallySelected(iterator._first, this)) ||
                (iterator._last && isNonTextPartiallySelected(iterator._last, this)));
                iterator.detach();
                return !boundariesInvalid;
            },

            detach : function () {
                detacher(this);
            },

            splitBoundaries : function () {
                assertRangeValid(this);

                var sc = this.startContainer, so = this.startOffset, ec = this.endContainer, eo = this.endOffset;
                var startEndSame = (sc === ec);

                if (dom.isCharacterDataNode(ec) && eo < ec.length) {
                    dom.splitDataNode(ec, eo);
                }

                if (dom.isCharacterDataNode(sc) && so > 0) {
                    sc = dom.splitDataNode(sc, so);
                    if (startEndSame) {
                        eo -= so;
                        ec = sc;
                    } else if (ec == sc.parentNode && eo >= dom.getNodeIndex(sc)) {
                        eo++;
                    }
                    so = 0;
                }
                boundaryUpdater(this, sc, so, ec, eo);
            },

            normalizeBoundaries : function () {
                assertRangeValid(this);

                var sc = this.startContainer, so = this.startOffset, ec = this.endContainer, eo = this.endOffset;

                var mergeForward = function (node) {
                    var sibling = node.nextSibling;
                    if (sibling && sibling.nodeType == node.nodeType) {
                        ec = node;
                        eo = node.length;
                        node.appendData(sibling.data);
                        sibling.parentNode.removeChild(sibling);
                    }
                };

                var mergeBackward = function (node) {
                    var sibling = node.previousSibling;
                    if (sibling && sibling.nodeType == node.nodeType) {
                        sc = node;
                        var nodeLength = node.length;
                        so = sibling.length;
                        node.insertData(0, sibling.data);
                        sibling.parentNode.removeChild(sibling);
                        if (sc == ec) {
                            eo += so;
                            ec = sc;
                        } else if (ec == node.parentNode) {
                            var nodeIndex = dom.getNodeIndex(node);
                            if (eo == nodeIndex) {
                                ec = node;
                                eo = nodeLength;
                            } else if (eo > nodeIndex) {
                                eo--;
                            }
                        }
                    }
                };

                var normalizeStart = true;

                if (dom.isCharacterDataNode(ec)) {
                    if (ec.length == eo) {
                        mergeForward(ec);
                    }
                } else {
                    if (eo > 0) {
                        var endNode = ec.childNodes[eo - 1];
                        if (endNode && dom.isCharacterDataNode(endNode)) {
                            mergeForward(endNode);
                        }
                    }
                    normalizeStart = !this.collapsed;
                }

                if (normalizeStart) {
                    if (dom.isCharacterDataNode(sc)) {
                        if (so == 0) {
                            mergeBackward(sc);
                        }
                    } else {
                        if (so < sc.childNodes.length) {
                            var startNode = sc.childNodes[so];
                            if (startNode && dom.isCharacterDataNode(startNode)) {
                                mergeBackward(startNode);
                            }
                        }
                    }
                } else {
                    sc = ec;
                    so = eo;
                }

                boundaryUpdater(this, sc, so, ec, eo);
            },

            collapseToPoint : function (node, offset) {
                assertNotDetached(this);

                assertNoDocTypeNotationEntityAncestor(node, true);
                assertValidOffset(node, offset);

                setRangeStartAndEnd(this, node, offset);
            }
        });

        copyComparisonConstants(constructor);
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    // Updates commonAncestorContainer and collapsed after boundary change
    function updateCollapsedAndCommonAncestor(range) {
        range.collapsed = (range.startContainer === range.endContainer && range.startOffset === range.endOffset);
        range.commonAncestorContainer = range.collapsed ?
            range.startContainer : dom.getCommonAncestor(range.startContainer, range.endContainer);
    }

    function updateBoundaries(range, startContainer, startOffset, endContainer, endOffset) {
        var startMoved = (range.startContainer !== startContainer || range.startOffset !== startOffset);
        var endMoved = (range.endContainer !== endContainer || range.endOffset !== endOffset);

        range.startContainer = startContainer;
        range.startOffset = startOffset;
        range.endContainer = endContainer;
        range.endOffset = endOffset;

        updateCollapsedAndCommonAncestor(range);
        dispatchEvent(range, "boundarychange", {startMoved : startMoved, endMoved : endMoved});
    }

    function detach(range) {
        assertNotDetached(range);
        range.startContainer = range.startOffset = range.endContainer = range.endOffset = null;
        range.collapsed = range.commonAncestorContainer = null;
        dispatchEvent(range, "detach", null);
        range._listeners = null;
    }

    /**
     * @constructor
     */
    function Range(doc) {
        this.startContainer = doc;
        this.startOffset = 0;
        this.endContainer = doc;
        this.endOffset = 0;
        this._listeners = {
            boundarychange : [],
            detach : []
        };
        updateCollapsedAndCommonAncestor(this);
    }

    createPrototypeRange(Range, updateBoundaries, detach);

    api.rangePrototype = RangePrototype.prototype;

    Range.rangeProperties = rangeProperties;
    Range.RangeIterator = RangeIterator;
    Range.copyComparisonConstants = copyComparisonConstants;
    Range.createPrototypeRange = createPrototypeRange;
    Range.inspect = inspect;
    Range.getRangeDocument = getRangeDocument;
    Range.rangesEqual = function (r1, r2) {
        return r1.startContainer === r2.startContainer && r1.startOffset === r2.startOffset && r1.endContainer === r2.endContainer && r1.endOffset === r2.endOffset;
    };

    api.DomRange = Range;
    api.RangeException = RangeException;
});
rangy.createModule("WrappedRange", function (api, module) {
    api.requireModules(["DomUtil", "DomRange"]);

    /**
     * @constructor
     */
    var WrappedRange;
    var dom = api.dom;
    var DomPosition = dom.DomPosition;
    var DomRange = api.DomRange;

    /*----------------------------------------------------------------------------------------------------------------*/

    /*
     This is a workaround for a bug where IE returns the wrong container element from the TextRange's parentElement()
     method. For example, in the following (where pipes denote the selection boundaries):

     <ul id="ul"><li id="a">| a </li><li id="b"> b |</li></ul>

     var range = document.selection.createRange();
     alert(range.parentElement().id); // Should alert "ul" but alerts "b"

     This method returns the common ancestor node of the following:
     - the parentElement() of the textRange
     - the parentElement() of the textRange after calling collapse(true)
     - the parentElement() of the textRange after calling collapse(false)
     */
    function getTextRangeContainerElement(textRange) {
        var parentEl = textRange.parentElement();

        var range = textRange.duplicate();
        range.collapse(true);
        var startEl = range.parentElement();
        range = textRange.duplicate();
        range.collapse(false);
        var endEl = range.parentElement();
        var startEndContainer = (startEl == endEl) ? startEl : dom.getCommonAncestor(startEl, endEl);

        return startEndContainer == parentEl ? startEndContainer : dom.getCommonAncestor(parentEl, startEndContainer);
    }

    function textRangeIsCollapsed(textRange) {
        return textRange.compareEndPoints("StartToEnd", textRange) == 0;
    }

    // Gets the boundary of a TextRange expressed as a node and an offset within that node. This function started out as
    // an improved version of code found in Tim Cameron Ryan's IERange (http://code.google.com/p/ierange/) but has
    // grown, fixing problems with line breaks in preformatted text, adding workaround for IE TextRange bugs, handling
    // for inputs and images, plus optimizations.
    function getTextRangeBoundaryPosition(textRange, wholeRangeContainerElement, isStart, isCollapsed) {
        var workingRange = textRange.duplicate();

        workingRange.collapse(isStart);
        var containerElement = workingRange.parentElement();

        // Sometimes collapsing a TextRange that's at the start of a text node can move it into the previous node, so
        // check for that
        // TODO: Find out when. Workaround for wholeRangeContainerElement may break this
        if (!dom.isAncestorOf(wholeRangeContainerElement, containerElement, true)) {
            containerElement = wholeRangeContainerElement;
        }

        // Deal with nodes that cannot "contain rich HTML markup". In practice, this means form inputs, images and
        // similar. See http://msdn.microsoft.com/en-us/library/aa703950%28VS.85%29.aspx
        if (!containerElement.canHaveHTML) {
            return new DomPosition(containerElement.parentNode, dom.getNodeIndex(containerElement));
        }

        var workingNode = dom.getDocument(containerElement).createElement("span");
        var comparison, workingComparisonType = isStart ? "StartToStart" : "StartToEnd";
        var previousNode, nextNode, boundaryPosition, boundaryNode;

        // Move the working range through the container's children, starting at the end and working backwards, until the
        // working range reaches or goes past the boundary we're interested in
        do {
            containerElement.insertBefore(workingNode, workingNode.previousSibling);
            workingRange.moveToElementText(workingNode);
        } while ((comparison = workingRange.compareEndPoints(workingComparisonType, textRange)) > 0 && workingNode.previousSibling);

        // We've now reached or gone past the boundary of the text range we're interested in
        // so have identified the node we want
        boundaryNode = workingNode.nextSibling;

        if (comparison == -1 && boundaryNode && dom.isCharacterDataNode(boundaryNode)) {
            // This is a character data node (text, comment, cdata). The working range is collapsed at the start of the
            // node containing the text range's boundary, so we move the end of the working range to the boundary point
            // and measure the length of its text to get the boundary's offset within the node.
            workingRange.setEndPoint(isStart ? "EndToStart" : "EndToEnd", textRange);

            var offset;

            if (/[\r\n]/.test(boundaryNode.data)) {
                /*
                 For the particular case of a boundary within a text node containing line breaks (within a <pre> element,
                 for example), we need a slightly complicated approach to get the boundary's offset in IE. The facts:

                 - Each line break is represented as \r in the text node's data/nodeValue properties
                 - Each line break is represented as \r\n in the TextRange's 'text' property
                 - The 'text' property of the TextRange does not contain trailing line breaks

                 To get round the problem presented by the final fact above, we can use the fact that TextRange's
                 moveStart() and moveEnd() methods return the actual number of characters moved, which is not necessarily
                 the same as the number of characters it was instructed to move. The simplest approach is to use this to
                 store the characters moved when moving both the start and end of the range to the start of the document
                 body and subtracting the start offset from the end offset (the "move-negative-gazillion" method).
                 However, this is extremely slow when the document is large and the range is near the end of it. Clearly
                 doing the mirror image (i.e. moving the range boundaries to the end of the document) has the same
                 problem.

                 Another approach that works is to use moveStart() to move the start boundary of the range up to the end
                 boundary one character at a time and incrementing a counter with the value returned by the moveStart()
                 call. However, the check for whether the start boundary has reached the end boundary is expensive, so
                 this method is slow (although unlike "move-negative-gazillion" is largely unaffected by the location of
                 the range within the document).

                 The method below is a hybrid of the two methods above. It uses the fact that a string containing the
                 TextRange's 'text' property with each \r\n converted to a single \r character cannot be longer than the
                 text of the TextRange, so the start of the range is moved that length initially and then a character at
                 a time to make up for any trailing line breaks not contained in the 'text' property. This has good
                 performance in most situations compared to the previous two methods.
                 */
                var tempRange = workingRange.duplicate();
                var rangeLength = tempRange.text.replace(/\r\n/g, "\r").length;

                offset = tempRange.moveStart("character", rangeLength);
                while ((comparison = tempRange.compareEndPoints("StartToEnd", tempRange)) == -1) {
                    offset++;
                    tempRange.moveStart("character", 1);
                }
            } else {
                offset = workingRange.text.length;
            }
            boundaryPosition = new DomPosition(boundaryNode, offset);
        } else {
            // If the boundary immediately follows a character data node and this is the end boundary, we should favour
            // a position within that, and likewise for a start boundary preceding a character data node
            previousNode = (isCollapsed || !isStart) && workingNode.previousSibling;
            nextNode = (isCollapsed || isStart) && workingNode.nextSibling;

            if (nextNode && dom.isCharacterDataNode(nextNode)) {
                boundaryPosition = new DomPosition(nextNode, 0);
            } else if (previousNode && dom.isCharacterDataNode(previousNode)) {
                boundaryPosition = new DomPosition(previousNode, previousNode.length);
            } else {
                boundaryPosition = new DomPosition(containerElement, dom.getNodeIndex(workingNode));
            }
        }

        // Clean up
        workingNode.parentNode.removeChild(workingNode);

        return boundaryPosition;
    }

    // Returns a TextRange representing the boundary of a TextRange expressed as a node and an offset within that node.
    // This function started out as an optimized version of code found in Tim Cameron Ryan's IERange
    // (http://code.google.com/p/ierange/)
    function createBoundaryTextRange(boundaryPosition, isStart) {
        var boundaryNode, boundaryParent, boundaryOffset = boundaryPosition.offset;
        var doc = dom.getDocument(boundaryPosition.node);
        var workingNode, childNodes, workingRange = doc.body.createTextRange();
        var nodeIsDataNode = dom.isCharacterDataNode(boundaryPosition.node);

        if (nodeIsDataNode) {
            boundaryNode = boundaryPosition.node;
            boundaryParent = boundaryNode.parentNode;
        } else {
            childNodes = boundaryPosition.node.childNodes;
            boundaryNode = (boundaryOffset < childNodes.length) ? childNodes[boundaryOffset] : null;
            boundaryParent = boundaryPosition.node;
        }

        // Position the range immediately before the node containing the boundary
        workingNode = doc.createElement("span");

        // Making the working element non-empty element persuades IE to consider the TextRange boundary to be within the
        // element rather than immediately before or after it, which is what we want
        workingNode.innerHTML = "&#feff;";

        // insertBefore is supposed to work like appendChild if the second parameter is null. However, a bug report
        // for IERange suggests that it can crash the browser: http://code.google.com/p/ierange/issues/detail?id=12
        if (boundaryNode) {
            boundaryParent.insertBefore(workingNode, boundaryNode);
        } else {
            boundaryParent.appendChild(workingNode);
        }

        workingRange.moveToElementText(workingNode);
        workingRange.collapse(!isStart);

        // Clean up
        boundaryParent.removeChild(workingNode);

        // Move the working range to the text offset, if required
        if (nodeIsDataNode) {
            workingRange[isStart ? "moveStart" : "moveEnd"]("character", boundaryOffset);
        }

        return workingRange;
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    if (api.features.implementsDomRange && (!api.features.implementsTextRange || !api.config.preferTextRange)) {
        // This is a wrapper around the browser's native DOM Range. It has two aims:
        // - Provide workarounds for specific browser bugs
        // - provide convenient extensions, which are inherited from Rangy's DomRange

        (function () {
            var rangeProto;
            var rangeProperties = DomRange.rangeProperties;
            var canSetRangeStartAfterEnd;

            function updateRangeProperties(range) {
                var i = rangeProperties.length, prop;
                while (i--) {
                    prop = rangeProperties[i];
                    range[prop] = range.nativeRange[prop];
                }
            }

            function updateNativeRange(range, startContainer, startOffset, endContainer, endOffset) {
                var startMoved = (range.startContainer !== startContainer || range.startOffset != startOffset);
                var endMoved = (range.endContainer !== endContainer || range.endOffset != endOffset);

                // Always set both boundaries for the benefit of IE9 (see issue 35)
                if (startMoved || endMoved) {
                    range.setEnd(endContainer, endOffset);
                    range.setStart(startContainer, startOffset);
                }
            }

            function detach(range) {
                range.nativeRange.detach();
                range.detached = true;
                var i = rangeProperties.length, prop;
                while (i--) {
                    prop = rangeProperties[i];
                    range[prop] = null;
                }
            }

            var createBeforeAfterNodeSetter;

            WrappedRange = function (range) {
                if (!range) {
                    throw new Error("Range must be specified");
                }
                this.nativeRange = range;
                updateRangeProperties(this);
            };

            DomRange.createPrototypeRange(WrappedRange, updateNativeRange, detach);

            rangeProto = WrappedRange.prototype;

            rangeProto.selectNode = function (node) {
                this.nativeRange.selectNode(node);
                updateRangeProperties(this);
            };

            rangeProto.deleteContents = function () {
                this.nativeRange.deleteContents();
                updateRangeProperties(this);
            };

            rangeProto.extractContents = function () {
                var frag = this.nativeRange.extractContents();
                updateRangeProperties(this);
                return frag;
            };

            rangeProto.cloneContents = function () {
                return this.nativeRange.cloneContents();
            };

            // TODO: Until I can find a way to programmatically trigger the Firefox bug (apparently long-standing, still
            // present in 3.6.8) that throws "Index or size is negative or greater than the allowed amount" for
            // insertNode in some circumstances, all browsers will have to use the Rangy's own implementation of
            // insertNode, which works but is almost certainly slower than the native implementation.
            /*
             rangeProto.insertNode = function(node) {
             this.nativeRange.insertNode(node);
             updateRangeProperties(this);
             };
             */

            rangeProto.surroundContents = function (node) {
                this.nativeRange.surroundContents(node);
                updateRangeProperties(this);
            };

            rangeProto.collapse = function (isStart) {
                this.nativeRange.collapse(isStart);
                updateRangeProperties(this);
            };

            rangeProto.cloneRange = function () {
                return new WrappedRange(this.nativeRange.cloneRange());
            };

            rangeProto.refresh = function () {
                updateRangeProperties(this);
            };

            rangeProto.toString = function () {
                return this.nativeRange.toString();
            };

            // Create test range and node for feature detection

            var testTextNode = document.createTextNode("test");
            dom.getBody(document).appendChild(testTextNode);
            var range = document.createRange();

            /*--------------------------------------------------------------------------------------------------------*/

            // Test for Firefox 2 bug that prevents moving the start of a Range to a point after its current end and
            // correct for it

            range.setStart(testTextNode, 0);
            range.setEnd(testTextNode, 0);

            try {
                range.setStart(testTextNode, 1);
                canSetRangeStartAfterEnd = true;

                rangeProto.setStart = function (node, offset) {
                    this.nativeRange.setStart(node, offset);
                    updateRangeProperties(this);
                };

                rangeProto.setEnd = function (node, offset) {
                    this.nativeRange.setEnd(node, offset);
                    updateRangeProperties(this);
                };

                createBeforeAfterNodeSetter = function (name) {
                    return function (node) {
                        this.nativeRange[name](node);
                        updateRangeProperties(this);
                    };
                };
            } catch (ex) {

                canSetRangeStartAfterEnd = false;

                rangeProto.setStart = function (node, offset) {
                    try {
                        this.nativeRange.setStart(node, offset);
                    } catch (ex) {
                        this.nativeRange.setEnd(node, offset);
                        this.nativeRange.setStart(node, offset);
                    }
                    updateRangeProperties(this);
                };

                rangeProto.setEnd = function (node, offset) {
                    try {
                        this.nativeRange.setEnd(node, offset);
                    } catch (ex) {
                        this.nativeRange.setStart(node, offset);
                        this.nativeRange.setEnd(node, offset);
                    }
                    updateRangeProperties(this);
                };

                createBeforeAfterNodeSetter = function (name, oppositeName) {
                    return function (node) {
                        try {
                            this.nativeRange[name](node);
                        } catch (ex) {
                            this.nativeRange[oppositeName](node);
                            this.nativeRange[name](node);
                        }
                        updateRangeProperties(this);
                    };
                };
            }

            rangeProto.setStartBefore = createBeforeAfterNodeSetter("setStartBefore", "setEndBefore");
            rangeProto.setStartAfter = createBeforeAfterNodeSetter("setStartAfter", "setEndAfter");
            rangeProto.setEndBefore = createBeforeAfterNodeSetter("setEndBefore", "setStartBefore");
            rangeProto.setEndAfter = createBeforeAfterNodeSetter("setEndAfter", "setStartAfter");

            /*--------------------------------------------------------------------------------------------------------*/

            // Test for and correct Firefox 2 behaviour with selectNodeContents on text nodes: it collapses the range to
            // the 0th character of the text node
            range.selectNodeContents(testTextNode);
            if (range.startContainer == testTextNode && range.endContainer == testTextNode && range.startOffset == 0 && range.endOffset == testTextNode.length) {
                rangeProto.selectNodeContents = function (node) {
                    this.nativeRange.selectNodeContents(node);
                    updateRangeProperties(this);
                };
            } else {
                rangeProto.selectNodeContents = function (node) {
                    this.setStart(node, 0);
                    this.setEnd(node, DomRange.getEndOffset(node));
                };
            }

            /*--------------------------------------------------------------------------------------------------------*/

            // Test for WebKit bug that has the beahviour of compareBoundaryPoints round the wrong way for constants
            // START_TO_END and END_TO_START: https://bugs.webkit.org/show_bug.cgi?id=20738

            range.selectNodeContents(testTextNode);
            range.setEnd(testTextNode, 3);

            var range2 = document.createRange();
            range2.selectNodeContents(testTextNode);
            range2.setEnd(testTextNode, 4);
            range2.setStart(testTextNode, 2);

            if (range.compareBoundaryPoints(range.START_TO_END, range2) == -1 &
                range.compareBoundaryPoints(range.END_TO_START, range2) == 1) {
                // This is the wrong way round, so correct for it

                rangeProto.compareBoundaryPoints = function (type, range) {
                    range = range.nativeRange || range;
                    if (type == range.START_TO_END) {
                        type = range.END_TO_START;
                    } else if (type == range.END_TO_START) {
                        type = range.START_TO_END;
                    }
                    return this.nativeRange.compareBoundaryPoints(type, range);
                };
            } else {
                rangeProto.compareBoundaryPoints = function (type, range) {
                    return this.nativeRange.compareBoundaryPoints(type, range.nativeRange || range);
                };
            }

            /*--------------------------------------------------------------------------------------------------------*/

            // Test for existence of createContextualFragment and delegate to it if it exists
            if (api.util.isHostMethod(range, "createContextualFragment")) {
                rangeProto.createContextualFragment = function (fragmentStr) {
                    return this.nativeRange.createContextualFragment(fragmentStr);
                };
            }

            /*--------------------------------------------------------------------------------------------------------*/

            // Clean up
            dom.getBody(document).removeChild(testTextNode);
            range.detach();
            range2.detach();
        })();

        api.createNativeRange = function (doc) {
            doc = doc || document;
            return doc.createRange();
        };
    } else if (api.features.implementsTextRange) {
        // This is a wrapper around a TextRange, providing full DOM Range functionality using rangy's DomRange as a
        // prototype

        WrappedRange = function (textRange) {
            this.textRange = textRange;
            this.refresh();
        };

        WrappedRange.prototype = new DomRange(document);

        WrappedRange.prototype.refresh = function () {
            var start, end;

            // TextRange's parentElement() method cannot be trusted. getTextRangeContainerElement() works around that.
            var rangeContainerElement = getTextRangeContainerElement(this.textRange);

            if (textRangeIsCollapsed(this.textRange)) {
                end = start = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, true, true);
            } else {

                start = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, true, false);
                end = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, false, false);
            }

            this.setStart(start.node, start.offset);
            this.setEnd(end.node, end.offset);
        };

        DomRange.copyComparisonConstants(WrappedRange);

        // Add WrappedRange as the Range property of the global object to allow expression like Range.END_TO_END to work
        var globalObj = (function () {
            return this;
        })();
        if (typeof globalObj.Range == "undefined") {
            globalObj.Range = WrappedRange;
        }

        api.createNativeRange = function (doc) {
            doc = doc || document;
            return doc.body.createTextRange();
        };
    }

    if (api.features.implementsTextRange) {
        WrappedRange.rangeToTextRange = function (range) {
            if (range.collapsed) {
                var tr = createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);

                return tr;

                //return createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);
            } else {
                var startRange = createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);
                var endRange = createBoundaryTextRange(new DomPosition(range.endContainer, range.endOffset), false);
                var textRange = dom.getDocument(range.startContainer).body.createTextRange();
                textRange.setEndPoint("StartToStart", startRange);
                textRange.setEndPoint("EndToEnd", endRange);
                return textRange;
            }
        };
    }

    WrappedRange.prototype.getName = function () {
        return "WrappedRange";
    };

    api.WrappedRange = WrappedRange;

    api.createRange = function (doc) {
        doc = doc || document;
        return new WrappedRange(api.createNativeRange(doc));
    };

    api.createRangyRange = function (doc) {
        doc = doc || document;
        return new DomRange(doc);
    };

    api.createIframeRange = function (iframeEl) {
        return api.createRange(dom.getIframeDocument(iframeEl));
    };

    api.createIframeRangyRange = function (iframeEl) {
        return api.createRangyRange(dom.getIframeDocument(iframeEl));
    };

    api.addCreateMissingNativeApiListener(function (win) {
        var doc = win.document;
        if (typeof doc.createRange == "undefined") {
            doc.createRange = function () {
                return api.createRange(this);
            };
        }
        doc = win = null;
    });
});
rangy.createModule("WrappedSelection", function (api, module) {
    // This will create a selection object wrapper that follows the Selection object found in the WHATWG draft DOM Range
    // spec (http://html5.org/specs/dom-range.html)

    api.requireModules(["DomUtil", "DomRange", "WrappedRange"]);

    api.config.checkSelectionRanges = true;

    var BOOLEAN = "boolean",
        windowPropertyName = "_rangySelection",
        dom = api.dom,
        util = api.util,
        DomRange = api.DomRange,
        WrappedRange = api.WrappedRange,
        DOMException = api.DOMException,
        DomPosition = dom.DomPosition,
        getSelection,
        selectionIsCollapsed,
        CONTROL = "Control";

    function getWinSelection(winParam) {
        return (winParam || window).getSelection();
    }

    function getDocSelection(winParam) {
        return (winParam || window).document.selection;
    }

    // Test for the Range/TextRange and Selection features required
    // Test for ability to retrieve selection
    var implementsWinGetSelection = api.util.isHostMethod(window, "getSelection"),
        implementsDocSelection = api.util.isHostObject(document, "selection");

    var useDocumentSelection = implementsDocSelection && (!implementsWinGetSelection || api.config.preferTextRange);

    if (useDocumentSelection) {
        getSelection = getDocSelection;
        api.isSelectionValid = function (winParam) {
            var doc = (winParam || window).document, nativeSel = doc.selection;

            // Check whether the selection TextRange is actually contained within the correct document
            return (nativeSel.type != "None" || dom.getDocument(nativeSel.createRange().parentElement()) == doc);
        };
    } else if (implementsWinGetSelection) {
        getSelection = getWinSelection;
        api.isSelectionValid = function () {
            return true;
        };
    } else {
        module.fail("Neither document.selection or window.getSelection() detected.");
    }

    api.getNativeSelection = getSelection;

    var testSelection = getSelection();
    var testRange = api.createNativeRange(document);
    var body = dom.getBody(document);

    // Obtaining a range from a selection
    var selectionHasAnchorAndFocus = util.areHostObjects(testSelection, ["anchorNode", "focusNode"] && util.areHostProperties(testSelection, ["anchorOffset", "focusOffset"]));
    api.features.selectionHasAnchorAndFocus = selectionHasAnchorAndFocus;

    // Test for existence of native selection extend() method
    var selectionHasExtend = util.isHostMethod(testSelection, "extend");
    api.features.selectionHasExtend = selectionHasExtend;

    // Test if rangeCount exists
    var selectionHasRangeCount = (typeof testSelection.rangeCount == "number");
    api.features.selectionHasRangeCount = selectionHasRangeCount;

    var selectionSupportsMultipleRanges = false;
    var collapsedNonEditableSelectionsSupported = true;

    if (util.areHostMethods(testSelection, ["addRange", "getRangeAt", "removeAllRanges"]) && typeof testSelection.rangeCount == "number" && api.features.implementsDomRange) {

        (function () {
            var iframe = document.createElement("iframe");
            body.appendChild(iframe);

            var iframeDoc = dom.getIframeDocument(iframe);
            iframeDoc.open();
            iframeDoc.write("<html><head></head><body>12</body></html>");
            iframeDoc.close();

            var sel = dom.getIframeWindow(iframe).getSelection();
            var docEl = iframeDoc.documentElement;
            var iframeBody = docEl.lastChild, textNode = iframeBody.firstChild;

            // Test whether the native selection will allow a collapsed selection within a non-editable element
            var r1 = iframeDoc.createRange();
            r1.setStart(textNode, 1);
            r1.collapse(true);
            sel.addRange(r1);
            collapsedNonEditableSelectionsSupported = (sel.rangeCount == 1);
            sel.removeAllRanges();

            // Test whether the native selection is capable of supporting multiple ranges
            var r2 = r1.cloneRange();
            r1.setStart(textNode, 0);
            r2.setEnd(textNode, 2);
            sel.addRange(r1);
            sel.addRange(r2);

            selectionSupportsMultipleRanges = (sel.rangeCount == 2);

            // Clean up
            r1.detach();
            r2.detach();

            body.removeChild(iframe);
        })();
    }

    api.features.selectionSupportsMultipleRanges = selectionSupportsMultipleRanges;
    api.features.collapsedNonEditableSelectionsSupported = collapsedNonEditableSelectionsSupported;

    // ControlRanges
    var implementsControlRange = false, testControlRange;

    if (body && util.isHostMethod(body, "createControlRange")) {
        testControlRange = body.createControlRange();
        if (util.areHostProperties(testControlRange, ["item", "add"])) {
            implementsControlRange = true;
        }
    }
    api.features.implementsControlRange = implementsControlRange;

    // Selection collapsedness
    if (selectionHasAnchorAndFocus) {
        selectionIsCollapsed = function (sel) {
            return sel.anchorNode === sel.focusNode && sel.anchorOffset === sel.focusOffset;
        };
    } else {
        selectionIsCollapsed = function (sel) {
            return sel.rangeCount ? sel.getRangeAt(sel.rangeCount - 1).collapsed : false;
        };
    }

    function updateAnchorAndFocusFromRange(sel, range, backwards) {
        var anchorPrefix = backwards ? "end" : "start", focusPrefix = backwards ? "start" : "end";
        sel.anchorNode = range[anchorPrefix + "Container"];
        sel.anchorOffset = range[anchorPrefix + "Offset"];
        sel.focusNode = range[focusPrefix + "Container"];
        sel.focusOffset = range[focusPrefix + "Offset"];
    }

    function updateAnchorAndFocusFromNativeSelection(sel) {
        var nativeSel = sel.nativeSelection;
        sel.anchorNode = nativeSel.anchorNode;
        sel.anchorOffset = nativeSel.anchorOffset;
        sel.focusNode = nativeSel.focusNode;
        sel.focusOffset = nativeSel.focusOffset;
    }

    function updateEmptySelection(sel) {
        sel.anchorNode = sel.focusNode = null;
        sel.anchorOffset = sel.focusOffset = 0;
        sel.rangeCount = 0;
        sel.isCollapsed = true;
        sel._ranges.length = 0;
    }

    function getNativeRange(range) {
        var nativeRange;
        if (range instanceof DomRange) {
            nativeRange = range._selectionNativeRange;
            if (!nativeRange) {
                nativeRange = api.createNativeRange(dom.getDocument(range.startContainer));
                nativeRange.setEnd(range.endContainer, range.endOffset);
                nativeRange.setStart(range.startContainer, range.startOffset);
                range._selectionNativeRange = nativeRange;
                range.attachListener("detach", function () {

                    this._selectionNativeRange = null;
                });
            }
        } else if (range instanceof WrappedRange) {
            nativeRange = range.nativeRange;
        } else if (api.features.implementsDomRange && (range instanceof dom.getWindow(range.startContainer).Range)) {
            nativeRange = range;
        }
        return nativeRange;
    }

    function rangeContainsSingleElement(rangeNodes) {
        if (!rangeNodes.length || rangeNodes[0].nodeType != 1) {
            return false;
        }
        for (var i = 1, len = rangeNodes.length;
             i < len;
             ++i) {
            if (!dom.isAncestorOf(rangeNodes[0], rangeNodes[i])) {
                return false;
            }
        }
        return true;
    }

    function getSingleElementFromRange(range) {
        var nodes = range.getNodes();
        if (!rangeContainsSingleElement(nodes)) {
            throw new Error("getSingleElementFromRange: range " + range.inspect() + " did not consist of a single element");
        }
        return nodes[0];
    }

    function isTextRange(range) {
        return !!range && typeof range.text != "undefined";
    }

    function updateFromTextRange(sel, range) {
        // Create a Range from the selected TextRange
        var wrappedRange = new WrappedRange(range);
        sel._ranges = [wrappedRange];

        updateAnchorAndFocusFromRange(sel, wrappedRange, false);
        sel.rangeCount = 1;
        sel.isCollapsed = wrappedRange.collapsed;
    }

    function updateControlSelection(sel) {
        // Update the wrapped selection based on what's now in the native selection
        sel._ranges.length = 0;
        if (sel.docSelection.type == "None") {
            updateEmptySelection(sel);
        } else {
            var controlRange = sel.docSelection.createRange();
            if (isTextRange(controlRange)) {
                // This case (where the selection type is "Control" and calling createRange() on the selection returns
                // a TextRange) can happen in IE 9. It happens, for example, when all elements in the selected
                // ControlRange have been removed from the ControlRange and removed from the document.
                updateFromTextRange(sel, controlRange);
            } else {
                sel.rangeCount = controlRange.length;
                var range, doc = dom.getDocument(controlRange.item(0));
                for (var i = 0;
                     i < sel.rangeCount;
                     ++i) {
                    range = api.createRange(doc);
                    range.selectNode(controlRange.item(i));
                    sel._ranges.push(range);
                }
                sel.isCollapsed = sel.rangeCount == 1 && sel._ranges[0].collapsed;
                updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], false);
            }
        }
    }

    function addRangeToControlSelection(sel, range) {
        var controlRange = sel.docSelection.createRange();
        var rangeElement = getSingleElementFromRange(range);

        // Create a new ControlRange containing all the elements in the selected ControlRange plus the element
        // contained by the supplied range
        var doc = dom.getDocument(controlRange.item(0));
        var newControlRange = dom.getBody(doc).createControlRange();
        for (var i = 0, len = controlRange.length;
             i < len;
             ++i) {
            newControlRange.add(controlRange.item(i));
        }
        try {
            newControlRange.add(rangeElement);
        } catch (ex) {
            throw new Error("addRange(): Element within the specified Range could not be added to control selection (does it have layout?)");
        }
        newControlRange.select();

        // Update the wrapped selection based on what's now in the native selection
        updateControlSelection(sel);
    }

    var getSelectionRangeAt;

    if (util.isHostMethod(testSelection, "getRangeAt")) {
        getSelectionRangeAt = function (sel, index) {
            try {
                return sel.getRangeAt(index);
            } catch (ex) {
                return null;
            }
        };
    } else if (selectionHasAnchorAndFocus) {
        getSelectionRangeAt = function (sel) {
            var doc = dom.getDocument(sel.anchorNode);
            var range = api.createRange(doc);
            range.setStart(sel.anchorNode, sel.anchorOffset);
            range.setEnd(sel.focusNode, sel.focusOffset);

            // Handle the case when the selection was selected backwards (from the end to the start in the
            // document)
            if (range.collapsed !== this.isCollapsed) {
                range.setStart(sel.focusNode, sel.focusOffset);
                range.setEnd(sel.anchorNode, sel.anchorOffset);
            }

            return range;
        };
    }

    /**
     * @constructor
     */
    function WrappedSelection(selection, docSelection, win) {
        this.nativeSelection = selection;
        this.docSelection = docSelection;
        this._ranges = [];
        this.win = win;
        this.refresh();
    }

    api.getSelection = function (win) {
        win = win || window;
        var sel = win[windowPropertyName];
        var nativeSel = getSelection(win), docSel = implementsDocSelection ? getDocSelection(win) : null;
        if (sel) {
            sel.nativeSelection = nativeSel;
            sel.docSelection = docSel;
            sel.refresh(win);
        } else {
            sel = new WrappedSelection(nativeSel, docSel, win);
            win[windowPropertyName] = sel;
        }
        return sel;
    };

    api.getSelectionWithoutRefersh = function (win) {
        win = win || window;
        var sel = win[windowPropertyName];
        var nativeSel = getSelection(win), docSel = implementsDocSelection ? getDocSelection(win) : null;
        if (sel) {
            sel.nativeSelection = nativeSel;
            sel.docSelection = docSel;
        } else {
            sel = new WrappedSelection(nativeSel, docSel, win);
            win[windowPropertyName] = sel;
        }
        return sel;
    };

    api.getIframeSelection = function (iframeEl) {
        return api.getSelection(dom.getIframeWindow(iframeEl));
    };

    var selProto = WrappedSelection.prototype;

    function createControlSelection(sel, ranges) {
        // Ensure that the selection becomes of type "Control"
        var doc = dom.getDocument(ranges[0].startContainer);
        var controlRange = dom.getBody(doc).createControlRange();
        for (var i = 0, el;
             i < rangeCount;
             ++i) {
            el = getSingleElementFromRange(ranges[i]);
            try {
                controlRange.add(el);
            } catch (ex) {
                throw new Error("setRanges(): Element within the one of the specified Ranges could not be added to control selection (does it have layout?)");
            }
        }
        controlRange.select();

        // Update the wrapped selection based on what's now in the native selection
        updateControlSelection(sel);
    }

    // Selecting a range
    if (!useDocumentSelection && selectionHasAnchorAndFocus && util.areHostMethods(testSelection, ["removeAllRanges", "addRange"])) {
        selProto.removeAllRanges = function () {
            this.nativeSelection.removeAllRanges();
            updateEmptySelection(this);
        };

        var addRangeBackwards = function (sel, range) {
            var doc = DomRange.getRangeDocument(range);
            var endRange = api.createRange(doc);
            endRange.collapseToPoint(range.endContainer, range.endOffset);
            sel.nativeSelection.addRange(getNativeRange(endRange));
            sel.nativeSelection.extend(range.startContainer, range.startOffset);
            sel.refresh();
        };

        if (selectionHasRangeCount) {
            selProto.addRange = function (range, backwards) {
                if (implementsControlRange && implementsDocSelection && this.docSelection.type == CONTROL) {
                    addRangeToControlSelection(this, range);
                } else {
                    if (backwards && selectionHasExtend) {
                        addRangeBackwards(this, range);
                    } else {
                        var previousRangeCount;
                        if (selectionSupportsMultipleRanges) {
                            previousRangeCount = this.rangeCount;
                        } else {
                            this.removeAllRanges();
                            previousRangeCount = 0;
                        }
                        this.nativeSelection.addRange(getNativeRange(range));

                        // Check whether adding the range was successful
                        this.rangeCount = this.nativeSelection.rangeCount;

                        if (this.rangeCount == previousRangeCount + 1) {
                            // The range was added successfully

                            // Check whether the range that we added to the selection is reflected in the last range extracted from
                            // the selection
                            if (api.config.checkSelectionRanges) {
                                var nativeRange = getSelectionRangeAt(this.nativeSelection, this.rangeCount - 1);
                                if (nativeRange && !DomRange.rangesEqual(nativeRange, range)) {
                                    // Happens in WebKit with, for example, a selection placed at the start of a text node
                                    range = new WrappedRange(nativeRange);
                                }
                            }
                            this._ranges[this.rangeCount - 1] = range;
                            updateAnchorAndFocusFromRange(this, range, selectionIsBackwards(this.nativeSelection));
                            this.isCollapsed = selectionIsCollapsed(this);
                        } else {
                            // The range was not added successfully. The simplest thing is to refresh
                            this.refresh();
                        }
                    }
                }
            };
        } else {
            selProto.addRange = function (range, backwards) {
                if (backwards && selectionHasExtend) {
                    addRangeBackwards(this, range);
                } else {
                    this.nativeSelection.addRange(getNativeRange(range));
                    this.refresh();
                }
            };
        }

        selProto.setRanges = function (ranges) {
            if (implementsControlRange && ranges.length > 1) {
                createControlSelection(this, ranges);
            } else {
                this.removeAllRanges();
                for (var i = 0, len = ranges.length;
                     i < len;
                     ++i) {
                    this.addRange(ranges[i]);
                }
            }
        };
    } else if (util.isHostMethod(testSelection, "empty") && util.isHostMethod(testRange, "select") && implementsControlRange && useDocumentSelection) {

        selProto.removeAllRanges = function () {
            // Added try/catch as fix for issue #21
            try {
                this.docSelection.empty();

                // Check for empty() not working (issue #24)
                if (this.docSelection.type != "None") {
                    // Work around failure to empty a control selection by instead selecting a TextRange and then
                    // calling empty()
                    var doc;
                    if (this.anchorNode) {
                        doc = dom.getDocument(this.anchorNode);
                    } else if (this.docSelection.type == CONTROL) {
                        var controlRange = this.docSelection.createRange();
                        if (controlRange.length) {
                            doc = dom.getDocument(controlRange.item(0)).body.createTextRange();
                        }
                    }
                    if (doc) {
                        var textRange = doc.body.createTextRange();
                        textRange.select();
                        this.docSelection.empty();
                    }
                }
            } catch (ex) {
            }
            updateEmptySelection(this);
        };

        selProto.addRange = function (range) {
            if (this.docSelection.type == CONTROL) {
                addRangeToControlSelection(this, range);
            } else {
                WrappedRange.rangeToTextRange(range).select();
                this._ranges[0] = range;
                this.rangeCount = 1;
                this.isCollapsed = this._ranges[0].collapsed;
                updateAnchorAndFocusFromRange(this, range, false);
            }
        };

        selProto.setRanges = function (ranges) {
            this.removeAllRanges();
            var rangeCount = ranges.length;
            if (rangeCount > 1) {
                createControlSelection(this, ranges);
            } else if (rangeCount) {
                this.addRange(ranges[0]);
            }
        };
    } else {
        module.fail("No means of selecting a Range or TextRange was found");
        return false;
    }

    selProto.getRangeAt = function (index) {
        if (index < 0 || index >= this.rangeCount) {
            throw new DOMException("INDEX_SIZE_ERR");
        } else {
            return this._ranges[index];
        }
    };

    var refreshSelection;

    if (useDocumentSelection) {
        refreshSelection = function (sel) {
            var range;
            if (api.isSelectionValid(sel.win)) {
                range = sel.docSelection.createRange();
            } else {
                range = dom.getBody(sel.win.document).createTextRange();
                range.collapse(true);
            }

            if (sel.docSelection.type == CONTROL) {
                updateControlSelection(sel);
            } else if (isTextRange(range)) {
                updateFromTextRange(sel, range);
            } else {
                updateEmptySelection(sel);
            }
        };
    } else if (util.isHostMethod(testSelection, "getRangeAt") && typeof testSelection.rangeCount == "number") {
        refreshSelection = function (sel) {
            if (implementsControlRange && implementsDocSelection && sel.docSelection.type == CONTROL) {
                updateControlSelection(sel);
            } else {
                sel._ranges.length = sel.rangeCount = sel.nativeSelection ? sel.nativeSelection.rangeCount : null;
                if (sel.rangeCount) {
                    for (var i = 0, len = sel.rangeCount;
                         i < len;
                         ++i) {
                        sel._ranges[i] = new api.WrappedRange(sel.nativeSelection.getRangeAt(i));
                    }
                    updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], selectionIsBackwards(sel.nativeSelection));
                    sel.isCollapsed = selectionIsCollapsed(sel);
                } else {
                    updateEmptySelection(sel);
                }
            }
        };
    } else if (selectionHasAnchorAndFocus && typeof testSelection.isCollapsed == BOOLEAN && typeof testRange.collapsed == BOOLEAN && api.features.implementsDomRange) {
        refreshSelection = function (sel) {
            var range, nativeSel = sel.nativeSelection;
            if (nativeSel.anchorNode) {
                range = getSelectionRangeAt(nativeSel, 0);
                sel._ranges = [range];
                sel.rangeCount = 1;
                updateAnchorAndFocusFromNativeSelection(sel);
                sel.isCollapsed = selectionIsCollapsed(sel);
            } else {
                updateEmptySelection(sel);
            }
        };
    } else {
        module.fail("No means of obtaining a Range or TextRange from the user's selection was found");
        return false;
    }

    selProto.refresh = function (checkForChanges) {
        var oldRanges = checkForChanges ? this._ranges.slice(0) : null;
        refreshSelection(this);
        if (checkForChanges) {
            var i = oldRanges.length;
            if (i != this._ranges.length) {
                return false;
            }
            while (i--) {
                if (!DomRange.rangesEqual(oldRanges[i], this._ranges[i])) {
                    return false;
                }
            }
            return true;
        }
    };

    // Removal of a single range
    var removeRangeManually = function (sel, range) {
        var ranges = sel.getAllRanges(), removed = false;
        sel.removeAllRanges();
        for (var i = 0, len = ranges.length;
             i < len;
             ++i) {
            if (removed || range !== ranges[i]) {
                sel.addRange(ranges[i]);
            } else {
                // According to the draft WHATWG Range spec, the same range may be added to the selection multiple
                // times. removeRange should only remove the first instance, so the following ensures only the first
                // instance is removed
                removed = true;
            }
        }
        if (!sel.rangeCount) {
            updateEmptySelection(sel);
        }
    };

    if (implementsControlRange) {
        selProto.removeRange = function (range) {
            if (this.docSelection.type == CONTROL) {
                var controlRange = this.docSelection.createRange();
                var rangeElement = getSingleElementFromRange(range);

                // Create a new ControlRange containing all the elements in the selected ControlRange minus the
                // element contained by the supplied range
                var doc = dom.getDocument(controlRange.item(0));
                var newControlRange = dom.getBody(doc).createControlRange();
                var el, removed = false;
                for (var i = 0, len = controlRange.length;
                     i < len;
                     ++i) {
                    el = controlRange.item(i);
                    if (el !== rangeElement || removed) {
                        newControlRange.add(controlRange.item(i));
                    } else {
                        removed = true;
                    }
                }
                newControlRange.select();

                // Update the wrapped selection based on what's now in the native selection
                updateControlSelection(this);
            } else {
                removeRangeManually(this, range);
            }
        };
    } else {
        selProto.removeRange = function (range) {
            removeRangeManually(this, range);
        };
    }

    // Detecting if a selection is backwards
    var selectionIsBackwards;
    if (!useDocumentSelection && selectionHasAnchorAndFocus && api.features.implementsDomRange) {
        selectionIsBackwards = function (sel) {
            var backwards = false;
            if (sel.anchorNode) {
                backwards = (dom.comparePoints(sel.anchorNode, sel.anchorOffset, sel.focusNode, sel.focusOffset) == 1);
            }
            return backwards;
        };

        selProto.isBackwards = function () {
            return selectionIsBackwards(this);
        };
    } else {
        selectionIsBackwards = selProto.isBackwards = function () {
            return false;
        };
    }

    // Selection text
    // This is conformant to the new WHATWG DOM Range draft spec but differs from WebKit and Mozilla's implementation
    selProto.toString = function () {

        var rangeTexts = [];
        for (var i = 0, len = this.rangeCount;
             i < len;
             ++i) {
            rangeTexts[i] = "" + this._ranges[i];
        }
        return rangeTexts.join("");
    };

    function assertNodeInSameDocument(sel, node) {
        if (sel.anchorNode && (dom.getDocument(sel.anchorNode) !== dom.getDocument(node))) {
            throw new DOMException("WRONG_DOCUMENT_ERR");
        }
    }

    // No current browsers conform fully to the HTML 5 draft spec for this method, so Rangy's own method is always used
    selProto.collapse = function (node, offset) {
        assertNodeInSameDocument(this, node);
        var range = api.createRange(dom.getDocument(node));
        range.collapseToPoint(node, offset);
        this.removeAllRanges();
        this.addRange(range);
        this.isCollapsed = true;
    };

    selProto.collapseToStart = function () {
        if (this.rangeCount) {
            var range = this._ranges[0];
            this.collapse(range.startContainer, range.startOffset);
        } else {
            throw new DOMException("INVALID_STATE_ERR");
        }
    };

    selProto.collapseToEnd = function () {
        if (this.rangeCount) {
            var range = this._ranges[this.rangeCount - 1];
            this.collapse(range.endContainer, range.endOffset);
        } else {
            throw new DOMException("INVALID_STATE_ERR");
        }
    };

    // The HTML 5 spec is very specific on how selectAllChildren should be implemented so the native implementation is
    // never used by Rangy.
    selProto.selectAllChildren = function (node) {
        assertNodeInSameDocument(this, node);
        var range = api.createRange(dom.getDocument(node));
        range.selectNodeContents(node);
        this.removeAllRanges();
        this.addRange(range);
    };

    selProto.deleteFromDocument = function () {
        // Sepcial behaviour required for Control selections
        if (implementsControlRange && implementsDocSelection && this.docSelection.type == CONTROL) {
            var controlRange = this.docSelection.createRange();
            var element;
            while (controlRange.length) {
                element = controlRange.item(0);
                controlRange.remove(element);
                element.parentNode.removeChild(element);
            }
            this.refresh();
        } else if (this.rangeCount) {
            var ranges = this.getAllRanges();
            this.removeAllRanges();
            for (var i = 0, len = ranges.length;
                 i < len;
                 ++i) {
                ranges[i].deleteContents();
            }
            // The HTML5 spec says nothing about what the selection should contain after calling deleteContents on each
            // range. Firefox moves the selection to where the final selected range was, so we emulate that
            this.addRange(ranges[len - 1]);
        }
    };

    // The following are non-standard extensions
    selProto.getAllRanges = function () {
        return this._ranges.slice(0);
    };

    selProto.setSingleRange = function (range) {
        this.setRanges([range]);
    };

    selProto.containsNode = function (node, allowPartial) {
        for (var i = 0, len = this._ranges.length;
             i < len;
             ++i) {
            if (this._ranges[i].containsNode(node, allowPartial)) {
                return true;
            }
        }
        return false;
    };

    selProto.toHtml = function () {
        var html = "";
        if (this.rangeCount) {
            var container = DomRange.getRangeDocument(this._ranges[0]).createElement("div");
            for (var i = 0, len = this._ranges.length;
                 i < len;
                 ++i) {
                container.appendChild(this._ranges[i].cloneContents());
            }
            html = container.innerHTML;
        }
        return html;
    };

    function inspect(sel) {
        var rangeInspects = [];
        var anchor = new DomPosition(sel.anchorNode, sel.anchorOffset);
        var focus = new DomPosition(sel.focusNode, sel.focusOffset);
        var name = (typeof sel.getName == "function") ? sel.getName() : "Selection";

        if (typeof sel.rangeCount != "undefined") {
            for (var i = 0, len = sel.rangeCount;
                 i < len;
                 ++i) {
                rangeInspects[i] = DomRange.inspect(sel.getRangeAt(i));
            }
        }
        return "[" + name + "(Ranges: " + rangeInspects.join(", ") +
            ")(anchor: " + anchor.inspect() + ", focus: " + focus.inspect() + "]";
    }

    selProto.getName = function () {
        return "WrappedSelection";
    };

    selProto.inspect = function () {
        return inspect(this);
    };

    selProto.detach = function () {
        this.win[windowPropertyName] = null;
        this.win = this.anchorNode = this.focusNode = null;
    };

    WrappedSelection.inspect = inspect;

    api.Selection = WrappedSelection;

    api.selectionPrototype = selProto;

    api.addCreateMissingNativeApiListener(function (win) {
        if (typeof win.getSelection == "undefined") {
            win.getSelection = function () {
                return api.getSelection(this);
            };
        }
        win = null;
    });
});
/*
 Base.js, version 1.1a
 Copyright 2006-2010, Dean Edwards
 License: http://www.opensource.org/licenses/mit-license.php
 */

var Base = function () {
    // dummy
};

Base.extend = function (_instance, _static) {// subclass
    var extend = Base.prototype.extend;

    // build the prototype
    Base._prototyping = true;
    var proto = new this;
    extend.call(proto, _instance);
    proto.base = function () {
        // call this method from any other method to invoke that method's ancestor
    };
    delete Base._prototyping;

    // create the wrapper for the constructor function
    //var constructor = proto.constructor.valueOf(); //-dean
    var constructor = proto.constructor;
    var klass = proto.constructor = function () {
        if (!Base._prototyping) {
            if (this._constructing || this.constructor == klass) {// instantiation
                this._constructing = true;
                constructor.apply(this, arguments);
                delete this._constructing;
            } else if (arguments[0] != null) {// casting
                return (arguments[0].extend || extend).call(arguments[0], proto);
            }
        }
    };

    // build the class interface
    klass.ancestor = this;
    klass.extend = this.extend;
    klass.forEach = this.forEach;
    klass.implement = this.implement;
    klass.prototype = proto;
    klass.toString = this.toString;
    klass.valueOf = function (type) {
        //return (type == "object") ? klass : constructor; //-dean
        return (type == "object") ? klass : constructor.valueOf();
    };
    extend.call(klass, _static);
    // class initialisation
    if (typeof klass.init == "function") {
        klass.init();
    }
    return klass;
};

Base.prototype = {
    extend : function (source, value) {
        if (arguments.length > 1) {// extending with a name/value pair
            var ancestor = this[source];
            if (ancestor && (typeof value == "function") && // overriding a method?
                // the valueOf() comparison is to avoid circular references
                (!ancestor.valueOf || ancestor.valueOf() != value.valueOf()) && /\bbase\b/.test(value)) {
                // get the underlying method
                var method = value.valueOf();
                // override
                value = function () {
                    var previous = this.base || Base.prototype.base;
                    this.base = ancestor;
                    var returnValue = method.apply(this, arguments);
                    this.base = previous;
                    return returnValue;
                };
                // point to the underlying method
                value.valueOf = function (type) {
                    return (type == "object") ? value : method;
                };
                value.toString = Base.toString;
            }
            this[source] = value;
        } else if (source) {// extending with an object literal
            var extend = Base.prototype.extend;
            // if this object has a customised extend method then use it
            if (!Base._prototyping && typeof this != "function") {
                extend = this.extend || extend;
            }
            var proto = {toSource : null};
            // do the "toString" and other methods manually
            var hidden = ["constructor", "toString", "valueOf"];
            // if we are prototyping then include the constructor
            var i = Base._prototyping ? 0 : 1;
            while (key = hidden[i++]) {
                if (source[key] != proto[key]) {
                    extend.call(this, key, source[key]);
                }
            }
            // copy each of the source object's properties to this object
            for (var key in source) {
                if (!proto[key]) {
                    extend.call(this, key, source[key]);
                }
            }
        }
        return this;
    }
};

// initialise
Base = Base.extend({
    constructor : function () {
        this.extend(arguments[0]);
    }
}, {
    ancestor : Object,
    version : "1.1",

    forEach : function (object, block, context) {
        for (var key in object) {
            if (this.prototype[key] === undefined) {
                block.call(context, object[key], key, object);
            }
        }
    },

    implement : function () {
        for (var i = 0;
             i < arguments.length;
             i++) {
            if (typeof arguments[i] == "function") {
                // if it's a function, call it
                arguments[i](this.prototype);
            } else {
                // add the interface using the extend method
                this.prototype.extend(arguments[i]);
            }
        }
        return this;
    },

    toString : function () {
        return String(this.valueOf());
    }
});
/**
 * Detect browser support for specific features
 */
wysihtml5.browser = (function () {
    var userAgent = navigator.userAgent,
        testElement = document.createElement("div"),
        // Browser sniffing is unfortunately needed since some behaviors are impossible to feature detect
        isGecko = userAgent.indexOf("Gecko") !== -1 && userAgent.indexOf("KHTML") === -1,
        isWebKit = userAgent.indexOf("AppleWebKit/") !== -1,
        isChrome = userAgent.indexOf("Chrome/") !== -1,
        isOpera = userAgent.indexOf("Opera/") !== -1;

    function detectIE() {
        var ua = window.navigator.userAgent;

        var msie = ua.indexOf('MSIE ');
        if (msie > 0) {
            // IE 10 or older => return version number
            return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
        }

        var trident = ua.indexOf('Trident/');
        if (trident > 0) {
            // IE 11 => return version number
            var rv = ua.indexOf('rv:');
            return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
        }

        var edge = ua.indexOf('Edge/');
        if (edge > 0) {
            // IE 12 => return version number
            return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
        }

        // other browser
        return false;
    }

    var isIE = detectIE();
    var isFireFox = userAgent ? (userAgent.toLowerCase().indexOf('firefox') !== -1) : 0;

    function iosVersion(userAgent) {
        return +((/ipad|iphone|ipod/.test(userAgent) && userAgent.match(/ os (\d+).+? like mac os x/)) || [, 0])[1];
    }

    function androidVersion(userAgent) {
        return +(userAgent.match(/android (\d+)/) || [, 0])[1];
    }

    return {
        // Static variable needed, publicly accessible, to be able override it in unit tests
        USER_AGENT : userAgent,

        // return true if browser is firefox
        isFireFox : isFireFox,

        // return true if browser is IE
        isIE : isIE,
        /**
         * Exclude browsers that are not capable of displaying and handling
         * contentEditable as desired:
         *    - iPhone, iPad (tested iOS 4.2.2) and Android (tested 2.2) refuse to make contentEditables focusable
         *    - IE < 8 create invalid markup and crash randomly from time to time
         *
         * @return {Boolean}
         */
        supported : function () {
            var userAgent = this.USER_AGENT.toLowerCase(),
                // Essential for making html elements editable
                hasContentEditableSupport = "contentEditable" in testElement,
                // Following methods are needed in order to interact with the contentEditable area
                hasEditingApiSupport = document.execCommand && document.queryCommandSupported && document.queryCommandState,
                // document selector apis are only supported by IE 8+, Safari 4+, Chrome and Firefox 3.5+
                hasQuerySelectorSupport = document.querySelector && document.querySelectorAll,
                // contentEditable is unusable in mobile browsers (tested iOS 4.2.2, Android 2.2, Opera Mobile, WebOS 3.05)
                isIncompatibleMobileBrowser = (this.isIos() && iosVersion(userAgent) < 5) || (this.isAndroid() && androidVersion(userAgent) < 4) || userAgent.indexOf("opera mobi") !== -1 || userAgent.indexOf("hpwos/") !== -1;
            return hasContentEditableSupport && hasEditingApiSupport && hasQuerySelectorSupport && !isIncompatibleMobileBrowser;
        },

        isTouchDevice : function () {
            return this.supportsEvent("touchmove");
        },

        isIos : function () {
            return (/ipad|iphone|ipod/i).test(this.USER_AGENT);
        },

        isAndroid : function () {
            return this.USER_AGENT.indexOf("Android") !== -1;
        },

        /**
         * Whether the browser supports sandboxed iframes
         * Currently only IE 6+ offers such feature <iframe security="restricted">
         *
         * http://msdn.microsoft.com/en-us/library/ms534622(v=vs.85).aspx
         * http://blogs.msdn.com/b/ie/archive/2008/01/18/using-frames-more-securely.aspx
         *
         * HTML5 sandboxed iframes are still buggy and their DOM is not reachable from the outside (except when using postMessage)
         */
        supportsSandboxedIframes : function () {
            return isIE;
        },

        /**
         * IE6+7 throw a mixed content warning when the src of an iframe
         * is empty/unset or about:blank
         * window.querySelector is implemented as of IE8
         */
        throwsMixedContentWarningWhenIframeSrcIsEmpty : function () {
            return !("querySelector" in document);
        },

        /**
         * Whether the caret is correctly displayed in contentEditable elements
         * Firefox sometimes shows a huge caret in the beginning after focusing
         */
        displaysCaretInEmptyContentEditableCorrectly : function () {
            return isIE;
        },

        /**
         * Opera and IE are the only browsers who offer the css value
         * in the original unit, thx to the currentStyle object
         * All other browsers provide the computed style in px via window.getComputedStyle
         */
        hasCurrentStyleProperty : function () {
            return "currentStyle" in testElement;
        },

        /**
         * Firefox on OSX navigates through history when hitting CMD + Arrow right/left
         */
        hasHistoryIssue : function () {
            return isGecko;
        },

        /**
         * Whether the browser inserts a <br> when pressing enter in a contentEditable element
         */
        insertsLineBreaksOnReturn : function () {
            return isGecko;
        },

        supportsPlaceholderAttributeOn : function (element) {
            return "placeholder" in element;
        },

        supportsEvent : function (eventName) {
            return "on" + eventName in testElement || (function () {
                    testElement.setAttribute("on" + eventName, "return;");
                    return typeof(testElement["on" + eventName]) === "function";
                })();
        },

        /**
         * Opera doesn't correctly fire focus/blur events when clicking in- and outside of iframe
         */
        supportsEventsInIframeCorrectly : function () {
            return !isOpera;
        },

        /**
         * Everything below IE9 doesn't know how to treat HTML5 tags
         *
         * @param {Object} context The document object on which to check HTML5 support
         *
         * @example
         *    wysihtml5.browser.supportsHTML5Tags(document);
         */
        supportsHTML5Tags : function (context) {
            var element = context.createElement("div"),
                html5 = "<article>foo</article>";
            element.innerHTML = html5;
            return element.innerHTML.toLowerCase() === html5;
        },

        /**
         * Checks whether a document supports a certain queryCommand
         * In particular, Opera needs a reference to a document that has a contentEditable in it's dom tree
         * in oder to report correct results
         *
         * @param {Object} doc Document object on which to check for a query command
         * @param {String} command The query command to check for
         * @return {Boolean}
         *
         * @example
         *    wysihtml5.browser.supportsCommand(document, "bold");
         */
        supportsCommand : (function () {
            // Following commands are supported but contain bugs in some browsers
            var buggyCommands = {
                // formatBlock fails with some tags (eg. <blockquote>)
                "formatBlock" : isIE,
                // When inserting unordered or ordered lists in Firefox, Chrome or Safari, the current selection or line gets
                // converted into a list (<ul><li>...</li></ul>, <ol><li>...</li></ol>)
                // IE and Opera act a bit different here as they convert the entire content of the current block element into a list
                "insertUnorderedList" : isIE || isWebKit || isFireFox,
                "insertOrderedList" : isIE || isWebKit
            };

            // Firefox throws errors for queryCommandSupported, so we have to build up our own object of supported commands
            var supported = {
                "insertHTML" : isGecko
            };

            return function (doc, command) {
                var isBuggy = buggyCommands[command];
                if (!isBuggy) {
                    // Firefox throws errors when invoking queryCommandSupported or queryCommandEnabled
                    try {
                        return doc.queryCommandSupported(command);
                    } catch (e1) {
                    }

                    try {
                        return doc.queryCommandEnabled(command);
                    } catch (e2) {
                        return !!supported[command];
                    }
                }
                return false;
            };
        })(),

        /**
         * IE: URLs starting with:
         *    www., http://, https://, ftp://, gopher://, mailto:, new:, snews:, telnet:, wasis:, file://,
         *    nntp://, newsrc:, ldap://, ldaps://, outlook:, mic:// and url:
         * will automatically be auto-linked when either the user inserts them via copy&paste or presses the
         * space bar when the caret is directly after such an url.
         * This behavior cannot easily be avoided in IE < 9 since the logic is hardcoded in the mshtml.dll
         * (related blog post on msdn
         * http://blogs.msdn.com/b/ieinternals/archive/2009/09/17/prevent-automatic-hyperlinking-in-contenteditable-html.aspx).
         */
        doesAutoLinkingInContentEditable : function () {
            return isIE;
        },

        /**
         * As stated above, IE auto links urls typed into contentEditable elements
         * Since IE9 it's possible to prevent this behavior
         */
        canDisableAutoLinking : function () {
            return this.supportsCommand(document, "AutoUrlDetect");
        },

        /**
         * IE leaves an empty paragraph in the contentEditable element after clearing it
         * Chrome/Safari sometimes an empty <div>
         */
        clearsContentEditableCorrectly : function () {
            return isGecko || isOpera || isWebKit;
        },

        /**
         * IE gives wrong results for getAttribute
         */
        supportsGetAttributeCorrectly : function () {
            var td = document.createElement("td");
            return td.getAttribute("rowspan") != "1";
        },

        /**
         * When clicking on images in IE, Opera and Firefox, they are selected, which makes it easy to interact with them.
         * Chrome and Safari both don't support this
         */
        canSelectImagesInContentEditable : function () {
            return isGecko || isIE || isOpera;
        },

        /**
         * All browsers except Safari and Chrome automatically scroll the range/caret position into view
         */
        autoScrollsToCaret : function () {
            return !isWebKit;
        },

        /**
         * Check whether the browser automatically closes tags that don't need to be opened
         */
        autoClosesUnclosedTags : function () {
            var clonedTestElement = testElement.cloneNode(false),
                returnValue,
                innerHTML;

            clonedTestElement.innerHTML = "<p><div></div>";
            innerHTML = clonedTestElement.innerHTML.toLowerCase();
            returnValue = innerHTML === "<p></p><div></div>" || innerHTML === "<p><div></div></p>";

            // Cache result by overwriting current function
            this.autoClosesUnclosedTags = function () {
                return returnValue;
            };

            return returnValue;
        },

        /**
         * Whether the browser supports the native document.getElementsByClassName which returns live NodeLists
         */
        supportsNativeGetElementsByClassName : function () {
            return String(document.getElementsByClassName).indexOf("[native code]") !== -1;
        },

        /**
         * As of now (19.04.2011) only supported by Firefox 4 and Chrome
         * See https://developer.mozilla.org/en/DOM/Selection/modify
         */
        supportsSelectionModify : function () {
            return "getSelection" in window && "modify" in window.getSelection();
        },

        /**
         * Opera needs a white space after a <br> in order to position the caret correctly
         */
        needsSpaceAfterLineBreak : function () {
            return isOpera;
        },

        /**
         * Whether the browser supports the speech api on the given element
         * See http://mikepultz.com/2011/03/accessing-google-speech-api-chrome-11/
         *
         * @example
         *    var input = document.createElement("input");
         *    if (wysihtml5.browser.supportsSpeechApiOn(input)) {
     *      // ...
     *    }
         */
        supportsSpeechApiOn : function (input) {
            var chromeVersion = userAgent.match(/Chrome\/(\d+)/) || [, 0];
            return chromeVersion[1] >= 11 && ("onwebkitspeechchange" in input || "speech" in input);
        },

        /**
         * IE9 crashes when setting a getter via Object.defineProperty on XMLHttpRequest or XDomainRequest
         * See https://connect.microsoft.com/ie/feedback/details/650112
         * or try the POC http://tifftiff.de/ie9_crash/
         */
        crashesWhenDefineProperty : function (property) {
            return isIE && (property === "XMLHttpRequest" || property === "XDomainRequest");
        },

        /**
         * IE is the only browser who fires the "focus" event not immediately when .focus() is called on an element
         */
        doesAsyncFocus : function () {
            return isIE;
        },

        /**
         * In IE it's impssible for the user and for the selection library to set the caret after an <img> when it's the lastChild in the document
         */
        hasProblemsSettingCaretAfterImg : function () {
            return isIE;
        },

        hasUndoInContextMenu : function () {
            return isGecko || isChrome || isOpera;
        },

        /**
         * Opera sometimes doesn't insert the node at the right position when range.insertNode(someNode)
         * is used (regardless if rangy or native)
         * This especially happens when the caret is positioned right after a <br> because then
         * insertNode() will insert the node right before the <br>
         */
        hasInsertNodeIssue : function () {
            return isOpera;
        },

        /**
         * IE 8+9 don't fire the focus event of the <body> when the iframe gets focused (even though the caret gets set into the <body>)
         */
        hasIframeFocusIssue : function () {
            return isIE;
        }
    };
})();
wysihtml5.lang.array = function (arr) {
    return {
        /**
         * Check whether a given object exists in an array
         *
         * @example
         *    wysihtml5.lang.array([1, 2]).contains(1);
         *    // => true
         */
        contains : function (needle) {
            if (arr.indexOf) {
                return arr.indexOf(needle) !== -1;
            } else {
                for (var i = 0, length = arr.length;
                     i < length;
                     i++) {
                    if (arr[i] === needle) {
                        return true;
                    }
                }
                return false;
            }
        },

        /**
         * Substract one array from another
         *
         * @example
         *    wysihtml5.lang.array([1, 2, 3, 4]).without([3, 4]);
         *    // => [1, 2]
         */
        without : function (arrayToSubstract) {
            arrayToSubstract = wysihtml5.lang.array(arrayToSubstract);
            var newArr = [],
                i = 0,
                length = arr.length;
            for (;
                i < length;
                i++) {
                if (!arrayToSubstract.contains(arr[i])) {
                    newArr.push(arr[i]);
                }
            }
            return newArr;
        },

        /**
         * Return a clean native array
         *
         * Following will convert a Live NodeList to a proper Array
         * @example
         *    var childNodes = wysihtml5.lang.array(document.body.childNodes).get();
         */
        get : function () {
            var i = 0,
                length = arr.length,
                newArray = [];
            for (;
                i < length;
                i++) {
                newArray.push(arr[i]);
            }
            return newArray;
        }
    };
};
wysihtml5.lang.Dispatcher = Base.extend(
    /** @scope wysihtml5.lang.Dialog.prototype */ {
        on : function (eventName, handler) {
            this.events = this.events || {};
            this.events[eventName] = this.events[eventName] || [];
            this.events[eventName].push(handler);
            return this;
        },

        off : function (eventName, handler) {
            this.events = this.events || {};
            var i = 0,
                handlers,
                newHandlers;
            if (eventName) {
                handlers = this.events[eventName] || [],
                    newHandlers = [];
                for (;
                    i < handlers.length;
                    i++) {
                    if (handlers[i] !== handler && handler) {
                        newHandlers.push(handlers[i]);
                    }
                }
                this.events[eventName] = newHandlers;
            } else {
                // Clean up all events
                this.events = {};
            }
            return this;
        },

        fire : function (eventName, payload) {
            this.events = this.events || {};
            var handlers = this.events[eventName] || [],
                i = 0;
            for (;
                i < handlers.length;
                i++) {
                handlers[i].call(this, payload);
            }
            return this;
        },

        // deprecated, use .on()
        observe : function () {
            return this.on.apply(this, arguments);
        },

        // deprecated, use .off()
        stopObserving : function () {
            return this.off.apply(this, arguments);
        }
    });
wysihtml5.lang.object = function (obj) {
    return {
        /**
         * @example
         *    wysihtml5.lang.object({ foo: 1, bar: 1 }).merge({ bar: 2, baz: 3 }).get();
         *    // => { foo: 1, bar: 2, baz: 3 }
         */
        merge : function (otherObj) {
            for (var i in otherObj) {
                obj[i] = otherObj[i];
            }
            return this;
        },

        get : function () {
            return obj;
        },

        /**
         * @example
         *    wysihtml5.lang.object({ foo: 1 }).clone();
         *    // => { foo: 1 }
         */
        clone : function () {
            var newObj = {},
                i;
            for (i in obj) {
                newObj[i] = obj[i];
            }
            return newObj;
        },

        /**
         * @example
         *    wysihtml5.lang.object([]).isArray();
         *    // => true
         */
        isArray : function () {
            return Object.prototype.toString.call(obj) === "[object Array]";
        }
    };
};
(function () {
    var WHITE_SPACE_START = /^\s+/,
        WHITE_SPACE_END = /\s+$/;
    wysihtml5.lang.string = function (str) {
        str = String(str);
        return {
            /**
             * @example
             *    wysihtml5.lang.string("   foo   ").trim();
             *    // => "foo"
             */
            trim : function () {
                return str.replace(WHITE_SPACE_START, "").replace(WHITE_SPACE_END, "");
            },

            /**
             * @example
             *    wysihtml5.lang.string("Hello #{name}").interpolate({ name: "Christopher" });
             *    // => "Hello Christopher"
             */
            interpolate : function (vars) {
                for (var i in vars) {
                    str = this.replace("#{" + i + "}").by(vars[i]);
                }
                return str;
            },

            /**
             * @example
             *    wysihtml5.lang.string("Hello Tom").replace("Tom").with("Hans");
             *    // => "Hello Hans"
             */
            replace : function (search) {
                return {
                    by : function (replace) {
                        return str.split(search).join(replace);
                    }
                };
            }
        };
    };
})();
/**
 * Find urls in descendant text nodes of an element and auto-links them
 * Inspired by http://james.padolsey.com/javascript/find-and-replace-text-with-javascript/
 *
 * @param {Element} element Container element in which to search for urls
 *
 * @example
 *    <div id="text-container">Please click here: www.google.com</div>
 *    <script>wysihtml5.dom.autoLink(document.getElementById("text-container"));</script>
 */
(function (wysihtml5) {
    var /**
         * Don't auto-link urls that are contained in the following elements:
         */
        IGNORE_URLS_IN = wysihtml5.lang.array(["CODE", "PRE", "A", "SCRIPT", "HEAD", "TITLE", "STYLE"]),
        /**
         * revision 1:
         *    /(\S+\.{1}[^\s\,\.\!]+)/g
         *
         * revision 2:
         *    /(\b(((https?|ftp):\/\/)|(www\.))[-A-Z0-9+&@#\/%?=~_|!:,.;\[\]]*[-A-Z0-9+&@#\/%=~_|])/gim
         *
         * put this in the beginning if you don't wan't to match within a word
         *    (^|[\>\(\{\[\s\>])
       */
        URL_REG_EXP = /((https?:\/\/|www\.)[^\s<]{3,})/gi,
        TRAILING_CHAR_REG_EXP = /([^\w\/\-](,?))$/i,
        MAX_DISPLAY_LENGTH = 100,
        BRACKETS = {")" : "(", "]" : "[", "}" : "{"};

    function autoLink(element) {
        if (_hasParentThatShouldBeIgnored(element)) {
            return element;
        }

        if (element === element.ownerDocument.documentElement) {
            element = element.ownerDocument.body;
        }

        return _parseNode(element);
    }

    /**
     * This is basically a rebuild of
     * the rails auto_link_urls text helper
     */
    function _convertUrlsToLinks(str) {
        return str.replace(URL_REG_EXP, function (match, url) {
            var punctuation = (url.match(TRAILING_CHAR_REG_EXP) || [])[1] || "",
                opening = BRACKETS[punctuation];
            url = url.replace(TRAILING_CHAR_REG_EXP, "");

            if (url.split(opening).length > url.split(punctuation).length) {
                url = url + punctuation;
                punctuation = "";
            }
            var realUrl = url,
                displayUrl = url;
            if (url.length > MAX_DISPLAY_LENGTH) {
                displayUrl = displayUrl.substr(0, MAX_DISPLAY_LENGTH) + "...";
            }
            // Add http prefix if necessary
            if (realUrl.substr(0, 4) === "www.") {
                realUrl = "http://" + realUrl;
            }

            return '<a href="' + realUrl + '">' + displayUrl + '</a>' + punctuation;
        });
    }

    /**
     * Creates or (if already cached) returns a temp element
     * for the given document object
     */
    function _getTempElement(context) {
        var tempElement = context._wysihtml5_tempElement;
        if (!tempElement) {
            tempElement = context._wysihtml5_tempElement = context.createElement("div");
        }
        return tempElement;
    }

    /**
     * Replaces the original text nodes with the newly auto-linked dom tree
     */
    function _wrapMatchesInNode(textNode) {
        var parentNode = textNode.parentNode,
            tempElement = _getTempElement(parentNode.ownerDocument);

        // We need to insert an empty/temporary <span /> to fix IE quirks
        // Elsewise IE would strip white space in the beginning
        tempElement.innerHTML = "<span></span>" + _convertUrlsToLinks(textNode.data);
        tempElement.removeChild(tempElement.firstChild);

        while (tempElement.firstChild) {
            // inserts tempElement.firstChild before textNode
            parentNode.insertBefore(tempElement.firstChild, textNode);
        }
        parentNode.removeChild(textNode);
    }

    function _hasParentThatShouldBeIgnored(node) {
        var nodeName;
        while (node.parentNode) {
            node = node.parentNode;
            nodeName = node.nodeName;
            if (IGNORE_URLS_IN.contains(nodeName)) {
                return true;
            } else if (!wysihtml5.util.isEditorNode(node)) {
                return false;
            }
        }
        return false;
    }

    function _parseNode(element) {
        if (IGNORE_URLS_IN.contains(element.nodeName)) {
            return;
        }

        if (element.nodeType === wysihtml5.TEXT_NODE && element.data.match(URL_REG_EXP)) {
            _wrapMatchesInNode(element);
            return;
        }

        var childNodes = wysihtml5.lang.array(element.childNodes).get(),
            childNodesLength = childNodes.length,
            i = 0;

        for (;
            i < childNodesLength;
            i++) {
            _parseNode(childNodes[i]);
        }

        return element;
    }

    wysihtml5.dom.autoLink = autoLink;

    // Reveal url reg exp to the outside
    wysihtml5.dom.autoLink.URL_REG_EXP = URL_REG_EXP;
})(wysihtml5);
(function (wysihtml5) {
    var api = wysihtml5.dom;

    api.addClass = function (element, className) {
        var classList = element.classList;
        if (classList) {
            return classList.add(className);
        }
        if (api.hasClass(element, className)) {
            return;
        }
        element.className += " " + className;
    };

    api.removeClass = function (element, className) {
        var classList = element.classList;
        if (classList) {
            return classList.remove(className);
        }

        element.className = element.className.replace(new RegExp("(^|\\s+)" + className + "(\\s+|$)"), " ");
    };

    api.hasClass = function (element, className) {
        var classList = element.classList;
        if (classList) {
            return classList.contains(className);
        }

        var elementClassName = element.className;
        return (elementClassName.length > 0 && (elementClassName == className || new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
    };
})(wysihtml5);
wysihtml5.dom.contains = (function () {
    var documentElement = document.documentElement;
    if (documentElement.contains) {
        return function (container, element) {
            if (element.nodeType !== wysihtml5.ELEMENT_NODE) {
                element = element.parentNode;
            }
            return container !== element && container.contains(element);
        };
    } else if (documentElement.compareDocumentPosition) {
        return function (container, element) {
            // https://developer.mozilla.org/en/DOM/Node.compareDocumentPosition
            return !!(container.compareDocumentPosition(element) & 16);
        };
    }
})();
/**
 * Converts an HTML fragment/element into a unordered/ordered list
 *
 * @param {Element} element The element which should be turned into a list
 * @param {String} listType The list type in which to convert the tree (either "ul" or "ol")
 * @return {Element} The created list
 *
 * @example
 *    <!-- Assume the following dom: -->
 *    <span id="pseudo-list">
 *      eminem<br>
 *      dr. dre
 *      <div>50 Cent</div>
 *    </span>
 *
 *    <script>
 *      wysihtml5.dom.convertToList(document.getElementById("pseudo-list"), "ul");
 *    </script>
 *
 *    <!-- Will result in: -->
 *    <ul>
 *      <li>eminem</li>
 *      <li>dr. dre</li>
 *      <li>50 Cent</li>
 *    </ul>
 */
wysihtml5.dom.convertToList = (function () {
    function _createListItem(doc, list, isBlockElement) {
        var listItem = doc.createElement("li");
        list.appendChild(listItem);
        if (isBlockElement) {
            return listItem;
        } else {
            var para = doc.createElement("p");
            listItem.appendChild(para);
            return para;
        }
    }

    function _createList(doc, type, listType) {
        var e = doc.createElement(type);
        if (listType && listType != "Ordered") {
            e.setAttribute("type", listType);
        }
        return e;
    }

    function convertToList(element, listType, type) {
        if (element.nodeName === "UL" || element.nodeName === "OL" || element.nodeName === "MENU") {
            // Already a list
            return element;
        }
        var doc = element.ownerDocument,
            list = _createList(doc, listType, type),
            lineBreaks = element.querySelectorAll("br"),
            lineBreaksLength = lineBreaks.length,
            childNodes,
            childNodesLength,
            childNode,
            lineBreak,
            parentNode,
            isBlockElement,
            isLineBreak,
            currentListItem,
            i;

        // First find <br> at the end of inline elements and move them behind them
        for (i = 0;
             i < lineBreaksLength;
             i++) {
            lineBreak = lineBreaks[i];
            while ((parentNode = lineBreak.parentNode) && parentNode !== element && parentNode.lastChild === lineBreak) {
                if (wysihtml5.dom.getStyle("display").from(parentNode) === "block") {
                    parentNode.removeChild(lineBreak);
                    break;
                }
                wysihtml5.dom.insert(lineBreak).after(lineBreak.parentNode);
            }
        }

        childNodes = wysihtml5.lang.array(element.childNodes).get();
        childNodesLength = childNodes.length;
        for (i = 0;
             i < childNodesLength;
             i++) {

            childNode = childNodes[i];
            isBlockElement = wysihtml5.dom.getStyle("display").from(childNode) === "block" || (childNode && childNode.querySelector && childNode.querySelector(wysihtml5.BLOCK_ELEMENTS_GROUP.join(",")));
            isLineBreak = childNode.nodeName === "BR";

            if (childNode && childNode.className == "_wysihtml5-temp-placeholder") {// ignore childNode creted by executeAndRestore
                continue;
            }

            if (isBlockElement) {
                currentListItem = _createListItem(doc, list, isBlockElement);
                currentListItem.appendChild(childNode);
                currentListItem = null;
                continue;
            }

            if (isLineBreak) {
                // Only create a new list item in the next iteration when the current one has already content,
                if (i != childNodesLength - 1) {
                    currentListItem = (currentListItem && currentListItem.firstChild) ? null : currentListItem;
                    continue;
                }
            }
            currentListItem = currentListItem || _createListItem(doc, list, isBlockElement);
            currentListItem.appendChild(childNode);
        }

        if (childNodes.length === 0) {
            _createListItem(doc, list);
        }

        element.parentNode.replaceChild(list, element);
        return list;
    }

    return convertToList;
})();
/**
 * Copy a set of attributes from one element to another
 *
 * @param {Array} attributesToCopy List of attributes which should be copied
 * @return {Object} Returns an object which offers the "from" method which can be invoked with the element where to
 *    copy the attributes from., this again returns an object which provides a method named "to" which can be invoked
 *    with the element where to copy the attributes to (see example)
 *
 * @example
 *    var textarea    = document.querySelector("textarea"),
 *        div         = document.querySelector("div[contenteditable=true]"),
 *        anotherDiv  = document.querySelector("div.preview");
 *    wysihtml5.dom.copyAttributes(["spellcheck", "value", "placeholder"]).from(textarea).to(div).andTo(anotherDiv);
 *
 */
wysihtml5.dom.copyAttributes = function (attributesToCopy) {
    return {
        from : function (elementToCopyFrom) {
            return {
                to : function (elementToCopyTo) {
                    var attribute,
                        i = 0,
                        length = attributesToCopy.length;
                    for (;
                        i < length;
                        i++) {
                        attribute = attributesToCopy[i];
                        if (typeof(elementToCopyFrom[attribute]) !== "undefined" && elementToCopyFrom[attribute] !== "") {
                            elementToCopyTo[attribute] = elementToCopyFrom[attribute];
                        }
                    }
                    return {andTo : arguments.callee};
                }
            };
        }
    };
};
/**
 * Copy a set of styles from one element to another
 * Please note that this only works properly across browsers when the element from which to copy the styles
 * is in the dom
 *
 * Interesting article on how to copy styles
 *
 * @param {Array} stylesToCopy List of styles which should be copied
 * @return {Object} Returns an object which offers the "from" method which can be invoked with the element where to
 *    copy the styles from., this again returns an object which provides a method named "to" which can be invoked
 *    with the element where to copy the styles to (see example)
 *
 * @example
 *    var textarea    = document.querySelector("textarea"),
 *        div         = document.querySelector("div[contenteditable=true]"),
 *        anotherDiv  = document.querySelector("div.preview");
 *    wysihtml5.dom.copyStyles(["overflow-y", "width", "height"]).from(textarea).to(div).andTo(anotherDiv);
 *
 */
(function (dom) {

    /**
     * Mozilla, WebKit and Opera recalculate the computed width when box-sizing: boder-box; is set
     * So if an element has "width: 200px; -moz-box-sizing: border-box; border: 1px;" then
     * its computed css width will be 198px
     *
     * See https://bugzilla.mozilla.org/show_bug.cgi?id=520992
     */
    var BOX_SIZING_PROPERTIES = ["-webkit-box-sizing", "-moz-box-sizing", "-ms-box-sizing", "box-sizing"];

    var shouldIgnoreBoxSizingBorderBox = function (element) {
        if (hasBoxSizingBorderBox(element)) {
            return parseInt(dom.getStyle("width").from(element), 10) < element.offsetWidth;
        }
        return false;
    };

    var hasBoxSizingBorderBox = function (element) {
        var i = 0,
            length = BOX_SIZING_PROPERTIES.length;
        for (;
            i < length;
            i++) {
            if (dom.getStyle(BOX_SIZING_PROPERTIES[i]).from(element) === "border-box") {
                return BOX_SIZING_PROPERTIES[i];
            }
        }
    };

    dom.copyStyles = function (stylesToCopy) {
        return {
            from : function (element) {
                if (shouldIgnoreBoxSizingBorderBox(element)) {
                    stylesToCopy = wysihtml5.lang.array(stylesToCopy).without(BOX_SIZING_PROPERTIES);
                }

                var cssText = "",
                    length = stylesToCopy.length,
                    i = 0,
                    property;
                for (;
                    i < length;
                    i++) {
                    property = stylesToCopy[i];
                    cssText += property + ":" + dom.getStyle(property).from(element) + ";";
                }

                return {
                    to : function (element) {
                        dom.setStyles(cssText).on(element);
                        return {andTo : arguments.callee};
                    }
                };
            }
        };
    };
})(wysihtml5.dom);
/**
 * Event Delegation
 *
 * @example
 *    wysihtml5.dom.delegate(document.body, "a", "click", function() {
 *      // foo
 *    });
 */
(function (wysihtml5) {

    wysihtml5.dom.delegate = function (container, selector, eventName, handler) {
        return wysihtml5.dom.observe(container, eventName, function (event) {
            var target = event.target,
                match = wysihtml5.lang.array(container.querySelectorAll(selector));

            while (target && target !== container) {
                if (match.contains(target)) {
                    handler.call(target, event);
                    break;
                }
                target = target.parentNode;
            }
        });
    };
})(wysihtml5);
/**
 * Returns the given html wrapped in a div element
 *
 * Fixing IE's inability to treat unknown elements (HTML5 section, article, ...) correctly
 * when inserted via innerHTML
 *
 * @param {String} html The html which should be wrapped in a dom element
 * @param {Obejct} [context] Document object of the context the html belongs to
 *
 * @example
 *    wysihtml5.dom.getAsDom("<article>foo</article>");
 */
wysihtml5.dom.getAsDom = (function () {

    var _innerHTMLShiv = function (html, context) {
        var tempElement = context.createElement("div");
        tempElement.style.display = "none";
        context.body.appendChild(tempElement);
        // IE throws an exception when trying to insert <frameset></frameset> via innerHTML
        try {
            tempElement.innerHTML = html;
        } catch (e) {
        }
        context.body.removeChild(tempElement);
        return tempElement;
    };

    /**
     * Make sure IE supports HTML5 tags, which is accomplished by simply creating one instance of each element
     */
    var _ensureHTML5Compatibility = function (context) {
        if (context._wysihtml5_supportsHTML5Tags) {
            return;
        }
        for (var i = 0, length = HTML5_ELEMENTS.length;
             i < length;
             i++) {
            context.createElement(HTML5_ELEMENTS[i]);
        }
        context._wysihtml5_supportsHTML5Tags = true;
    };

    /**
     * List of html5 tags
     * taken from http://simon.html5.org/html5-elements
     */
    var HTML5_ELEMENTS = [
        "abbr", "article", "aside", "audio", "bdi", "canvas", "command", "datalist", "details", "figcaption",
        "figure", "footer", "header", "hgroup", "keygen", "mark", "meter", "nav", "output", "progress",
        "rp", "rt", "ruby", "svg", "section", "source", "summary", "time", "track", "video", "wbr"
    ];

    return function (html, context) {
        context = context || document;
        var tempElement;
        if (typeof(html) === "object" && html.nodeType) {
            tempElement = context.createElement("div");
            tempElement.appendChild(html);
        } else if (wysihtml5.browser.supportsHTML5Tags(context)) {
            tempElement = context.createElement("div");
            tempElement.innerHTML = html;
        } else {
            _ensureHTML5Compatibility(context);
            tempElement = _innerHTMLShiv(html, context);
        }
        tempElement.classList.add("wysihtml5-editor");
        return tempElement;
    };
})();
/**
 * Walks the dom tree from the given node up until it finds a match
 * Designed for optimal performance.
 *
 * @param {Element} node The from which to check the parent nodes
 * @param {Object} matchingSet Object to match against (possible properties: nodeName, className, classRegExp)
 * @param {Number} [levels] How many parents should the function check up from the current node (defaults to 50)
 * @return {null|Element} Returns the first element that matched the desiredNodeName(s)
 * @example
 *    var listElement = wysihtml5.dom.getParentElement(document.querySelector("li"), { nodeName: ["MENU", "UL", "OL"] });
 *    // ... or ...
 *    var unorderedListElement = wysihtml5.dom.getParentElement(document.querySelector("li"), { nodeName: "UL" });
 *    // ... or ...
 *    var coloredElement = wysihtml5.dom.getParentElement(myTextNode, { nodeName: "SPAN", className: "wysiwyg-color-red", classRegExp: /wysiwyg-color-[a-z]/g });
 */
wysihtml5.dom.getParentElement = (function () {

    function _isSameNodeName(nodeName, desiredNodeNames) {
        if (!desiredNodeNames || !desiredNodeNames.length) {
            return true;
        }

        if (typeof(desiredNodeNames) === "string") {
            return nodeName === desiredNodeNames;
        } else {
            return wysihtml5.lang.array(desiredNodeNames).contains(nodeName);
        }
    }

    function _isElement(node) {
        return node.nodeType === wysihtml5.ELEMENT_NODE;
    }

    function _hasClassName(element, className, classRegExp) {
        var classNames = (element.className || "").match(classRegExp) || [];
        if (!className) {
            return !!classNames.length;
        }
        return classNames[classNames.length - 1] === className;
    }

    function _hasAttributes(el, attributes) {
        if (el.nodeType == wysihtml5.TEXT_NODE || el.nodeType == 9) {
            return false;
        }
        var st = el.getAttribute("style");
        if (!st) {
            return false;
        }
        for (var attribute in attributes) {
            if (el.style.getPropertyValue(attribute)) {
                if (attributes[attribute] != null && attributes[attribute] == el.style.getPropertyValue(attribute)) {
                    return true;
                } else if (attributes[attribute] == null) {
                    return true;
                }
            }
        }
        return false;
    }

    function _getParentElementWithNodeName(node, nodeName, levels) {
        while (levels-- && node) {
            if (_isSameNodeName(node.nodeName, nodeName)) {
                return node;
            }
            if (!wysihtml5.util.isEditorNode(node.parentNode)) {
                node = node.parentNode;
            } else {
                break;
            }
        }
        return null;
    }

    function _getParentElementWithNodeNameAndClassName(node, nodeName, className, classRegExp, levels) {
        while (levels-- && node) {
            if (_isElement(node) && _isSameNodeName(node.nodeName, nodeName) && _hasClassName(node, className, classRegExp)) {
                return node;
            }
            if (!wysihtml5.util.isEditorNode(node.parentNode)) {
                node = node.parentNode;
            } else {
                break;
            }
        }
        return null;
    }

    function _getParentElementWithNodeNameAndAttribute(node, nodeName, attributes, levels) {
        while (levels-- && node) {
            if (_isElement(node) && _isSameNodeName(node.nodeName, nodeName) && _hasAttributes(node, attributes)) {
                return node;
            }
            if (!wysihtml5.util.isEditorNode(node.parentNode)) {
                node = node.parentNode;
            } else {
                break;
            }
        }
        return null;
    }

    return function (node, matchingSet, levels) {
        levels = levels || 50; // Go max 50 nodes upwards from current node
        if (matchingSet.attributes) {
            return _getParentElementWithNodeNameAndAttribute(
                node, matchingSet.nodeName, matchingSet.attributes, levels
            );
        } else if (matchingSet.className || matchingSet.classRegExp) {
            return _getParentElementWithNodeNameAndClassName(
                node, matchingSet.nodeName, matchingSet.className, matchingSet.classRegExp, levels
            );
        } else {
            return _getParentElementWithNodeName(
                node, matchingSet.nodeName, levels
            );
        }
    };
})();
/**
 * Get element's style for a specific css property
 *
 * @param {Element} element The element on which to retrieve the style
 * @param {String} property The CSS property to retrieve ("float", "display", "text-align", ...)
 *
 * @example
 *    wysihtml5.dom.getStyle("display").from(document.body);
 *    // => "block"
 */
wysihtml5.dom.getStyle = (function () {
    var stylePropertyMapping = {
            "float" : ("styleFloat" in document.createElement("div").style) ? "styleFloat" : "cssFloat"
        },
        REG_EXP_CAMELIZE = /\-[a-z]/g;

    function camelize(str) {
        return str.replace(REG_EXP_CAMELIZE, function (match) {
            return match.charAt(1).toUpperCase();
        });
    }

    return function (property) {
        return {
            from : function (element) {
                if (element.nodeType !== wysihtml5.ELEMENT_NODE) {
                    return;
                }

                var doc = element.ownerDocument,
                    camelizedProperty = stylePropertyMapping[property] || camelize(property),
                    style = element.style,
                    currentStyle = element.currentStyle,
                    styleValue = style[camelizedProperty];
                if (styleValue) {
                    return styleValue;
                }

                // currentStyle is no standard and only supported by Opera and IE but it has one important advantage over the standard-compliant
                // window.getComputedStyle, since it returns css property values in their original unit:
                // If you set an elements width to "50%", window.getComputedStyle will give you it's current width in px while currentStyle
                // gives you the original "50%".
                // Opera supports both, currentStyle and window.getComputedStyle, that's why checking for currentStyle should have higher prio
                if (currentStyle) {
                    try {
                        return currentStyle[camelizedProperty];
                    } catch (e) {
                        //ie will occasionally fail for unknown reasons. swallowing exception
                    }
                }

                var win = doc.defaultView || doc.parentWindow,
                    needsOverflowReset = (property === "height" || property === "width") && element.nodeName === "TEXTAREA",
                    originalOverflow,
                    returnValue;

                if (win.getComputedStyle) {
                    // Chrome and Safari both calculate a wrong width and height for textareas when they have scroll bars
                    // therfore we remove and restore the scrollbar and calculate the value in between
                    if (needsOverflowReset) {
                        originalOverflow = style.overflow;
                        style.overflow = "hidden";
                    }
                    returnValue = win.getComputedStyle(element, null).getPropertyValue(property);
                    if (needsOverflowReset) {
                        style.overflow = originalOverflow || "";
                    }
                    return returnValue;
                }
            }
        };
    };
})();
/**
 * High performant way to check whether an element with a specific tag name is in the given document
 * Optimized for being heavily executed
 * Unleashes the power of live node lists
 *
 * @param {Object} doc The document object of the context where to check
 * @param {String} tagName Upper cased tag name
 * @example
 *    wysihtml5.dom.hasElementWithTagName(document, "IMG");
 */
wysihtml5.dom.hasElementWithTagName = (function () {
    var LIVE_CACHE = {},
        DOCUMENT_IDENTIFIER = 1;

    function _getDocumentIdentifier(doc) {
        return doc._wysihtml5_identifier || (doc._wysihtml5_identifier = DOCUMENT_IDENTIFIER++);
    }

    return function (doc, tagName) {
        var key = _getDocumentIdentifier(doc) + ":" + tagName,
            cacheEntry = LIVE_CACHE[key];
        if (!cacheEntry) {
            cacheEntry = LIVE_CACHE[key] = doc.getElementsByTagName(tagName);
        }

        return cacheEntry.length > 0;
    };
})();
/**
 * High performant way to check whether an element with a specific class name is in the given document
 * Optimized for being heavily executed
 * Unleashes the power of live node lists
 *
 * @param {Object} doc The document object of the context where to check
 * @param {String} tagName Upper cased tag name
 * @example
 *    wysihtml5.dom.hasElementWithClassName(document, "foobar");
 */
(function (wysihtml5) {
    var LIVE_CACHE = {},
        DOCUMENT_IDENTIFIER = 1;

    function _getDocumentIdentifier(doc) {
        return doc._wysihtml5_identifier || (doc._wysihtml5_identifier = DOCUMENT_IDENTIFIER++);
    }

    wysihtml5.dom.hasElementWithClassName = function (doc, className) {
        // getElementsByClassName is not supported by IE<9
        // but is sometimes mocked via library code (which then doesn't return live node lists)
        if (!wysihtml5.browser.supportsNativeGetElementsByClassName()) {
            return !!doc.querySelector("." + className);
        }

        var key = _getDocumentIdentifier(doc) + ":" + className,
            cacheEntry = LIVE_CACHE[key];
        if (!cacheEntry) {
            cacheEntry = LIVE_CACHE[key] = doc.getElementsByClassName(className);
        }

        return cacheEntry.length > 0;
    };
})(wysihtml5);
wysihtml5.dom.insert = function (elementToInsert) {
    return {
        after : function (element) {
            element.parentNode.insertBefore(elementToInsert, element.nextSibling ? element.nextSibling : null);
        },

        before : function (element) {
            element.parentNode.insertBefore(elementToInsert, element);
        },

        into : function (element) {
            element.appendChild(elementToInsert);
        }
    };
};
wysihtml5.dom.insertCSS = function (rules) {
    rules = rules.join("\n");

    return {
        into : function (doc) {
            var styleElement = doc.createElement("style");
            styleElement.type = "text/css";

            if (styleElement.styleSheet) {
                styleElement.styleSheet.cssText = rules;
            } else {
                styleElement.appendChild(doc.createTextNode(rules));
            }

            var link = doc.querySelector("head link");
            if (link) {
                link.parentNode.insertBefore(styleElement, link);
                return;
            } else {
                var head = doc.querySelector("head");
                if (head) {
                    head.appendChild(styleElement);
                }
            }
        }
    };
};
/**
 * Method to set dom events
 *
 * @example
 *    wysihtml5.dom.observe(iframe.contentWindow.document.body, ["focus", "blur"], function() { ... });
 */
wysihtml5.dom.observe = function (element, eventNames, handler) {
    eventNames = typeof(eventNames) === "string" ? [eventNames] : eventNames;

    var handlerWrapper,
        eventName,
        i = 0,
        length = eventNames.length;

    for (;
        i < length;
        i++) {
        eventName = eventNames[i];
        if (element.addEventListener) {
            element.addEventListener(eventName, handler, false);
        } else {
            handlerWrapper = function (event) {
                if (!("target" in event)) {
                    event.target = event.srcElement;
                }
                event.preventDefault = event.preventDefault || function () {
                        this.returnValue = false;
                    };
                event.stopPropagation = event.stopPropagation || function () {
                        this.cancelBubble = true;
                    };
                handler.call(element, event);
            };
            element.attachEvent("on" + eventName, handlerWrapper);
        }
    }

    return {
        stop : function () {
            var eventName,
                i = 0,
                length = eventNames.length;
            for (;
                i < length;
                i++) {
                eventName = eventNames[i];
                if (element.removeEventListener) {
                    element.removeEventListener(eventName, handler, false);
                } else {
                    element.detachEvent("on" + eventName, handlerWrapper);
                }
            }
        }
    };
};
/**
 * HTML Sanitizer
 * Rewrites the HTML based on given rules
 *
 * @param {Element|String} elementOrHtml HTML String to be sanitized OR element whose content should be sanitized
 * @param {Object} [rules] List of rules for rewriting the HTML, if there's no rule for an element it will
 *    be converted to a "span". Each rule is a key/value pair where key is the tag to convert, and value the
 *    desired substitution.
 * @param {Object} context Document object in which to parse the html, needed to sandbox the parsing
 *
 * @return {Element|String} Depends on the elementOrHtml parameter. When html then the sanitized html as string elsewise the element.
 *
 * @example
 *    var userHTML = '<div id="foo" onclick="alert(1);"><p><font color="red">foo</font><script>alert(1);</script></p></div>';
 *    wysihtml5.dom.parse(userHTML, {
 *      tags {
 *        p:      "div",      // Rename p tags to div tags
 *        font:   "span"      // Rename font tags to span tags
 *        div:    true,       // Keep them, also possible (same result when passing: "div" or true)
 *        script: undefined   // Remove script elements
 *      }
 *    });
 *    // => <div><div><span>foo bar</span></div></div>
 *
 *    var userHTML = '<table><tbody><tr><td>I'm a table!</td></tr></tbody></table>';
 *    wysihtml5.dom.parse(userHTML);
 *    // => '<span><span><span><span>I'm a table!</span></span></span></span>'
 *
 *    var userHTML = '<div>foobar<br>foobar</div>';
 *    wysihtml5.dom.parse(userHTML, {
 *      tags: {
 *        div: undefined,
 *        br:  true
 *      }
 *    });
 *    // => ''
 *
 *    var userHTML = '<div class="red">foo</div><div class="pink">bar</div>';
 *    wysihtml5.dom.parse(userHTML, {
 *      classes: {
 *        red:    1,
 *        green:  1
 *      },
 *      tags: {
 *        div: {
 *          rename_tag:     "p"
 *        }
 *      }
 *    });
 *    // => '<p class="red">foo</p><p>bar</p>'
 */
wysihtml5.dom.parse = (function () {

    /**
     * It's not possible to use a XMLParser/DOMParser as HTML5 is not always well-formed XML
     * new DOMParser().parseFromString('<img src="foo.gif">') will cause a parseError since the
     * node isn't closed
     *
     * Therefore we've to use the browser's ordinary HTML parser invoked by setting innerHTML.
     */
    var NODE_TYPE_MAPPING = {
            "1" : _handleElement,
            "3" : _handleText
        },
        // Rename unknown tags to this
        DEFAULT_NODE_NAME = "span",
        WHITE_SPACE_REG_EXP = /\s+/,
        defaultRules = {tags : {}, classes : {}},
        currentRules = {},
        preProcessingContent = false;

    /**
     * Iterates over all childs of the element, recreates them, appends them into a document fragment
     * which later replaces the entire body content
     */
    function parse(elementOrHtml, rules, context, cleanUp, preProcess) {
        wysihtml5.lang.object(currentRules).merge(defaultRules).merge(rules).get();

        context = context || elementOrHtml.ownerDocument || document;
        preProcessingContent = !!preProcess;
        var fragment = context.createDocumentFragment(),
            isString = typeof(elementOrHtml) === "string",
            element,
            newNode,
            firstChild;

        if (isString) {
            element = wysihtml5.dom.getAsDom(elementOrHtml, context);
            if (preProcess) {
                element.innerHTML = element.innerHTML.replace(/\r/g, "");
                element.innerHTML = element.innerHTML.replace(/\n/g, " ");
            }
            element.style.display = "none";
            context.body.appendChild(element);
        } else {
            var innerHTML = elementOrHtml.innerHTML;
            element = elementOrHtml;
            if (preProcess) {
                innerHTML = innerHTML.replace(/\r/g, "");
                innerHTML = innerHTML.replace(/\n/g, "");
            }
            element.innerHTML = innerHTML;
        }
        while (element.firstChild) {
            firstChild = element.firstChild;
            newNode = _convert(firstChild, cleanUp, "body");
            element.removeChild(firstChild);
            if (newNode) {
                fragment.appendChild(newNode);
            }
        }

        // Clear element contents
        element.innerHTML = "";

        // Insert new DOM tree
        element.appendChild(fragment);

        // Cleanup the Word To HTML Cache
        _cleanUpWordToHTMLCache();

        if (isString) {
            context.body.removeChild(element);
        }
        return isString ? wysihtml5.quirks.getCorrectInnerHTML(element) : element;
    }

    function _convert(oldNode, cleanUp, newParentNodeName) {
        var oldNodeType = oldNode.nodeType,
            oldChilds = oldNode.childNodes,
            method = NODE_TYPE_MAPPING[oldNodeType],
            i = 0,
            newNode,
            newChild;

        // Return null for #text nodes which has only whitespaces
        if (oldNodeType == 3 && !oldNode.data.trim().length && oldNode.parentNode.hasAttribute('class', 'wysihtml5-editor')) {
            return null;
        }

        newNode = method && method(oldNode, newParentNodeName);

        if (!newNode) {
            return null;
        }

        var oldChildsLength = oldChilds.length;
        for (i = 0;
             i < oldChildsLength;
             i++) {
            newChild = _convert(oldChilds[i], cleanUp, newNode.nodeName.toLowerCase());
            if (newChild) {
                newNode.appendChild(newChild);
            }
        }

        // Cleanup senseless <span> elements
        if (cleanUp && newNode.childNodes.length <= 1 && newNode.nodeName.toLowerCase() === DEFAULT_NODE_NAME && !newNode.attributes.length) {
            return newNode.firstChild;
        }

        return newNode;
    }

    function _handleElement(oldNode, newParentNodeName) {
        var rule,
            newNode,
            tagRules = currentRules.tags,
            pseudoTags = currentRules.pseudoTags || [],
            nodeName = oldNode.nodeName.toLowerCase(),
            scopeName = oldNode.scopeName,
            tableElements = ["table", "thead", "tfoot", "th", "colgroup", "col", "tbody", "tr", "td"];

        /**
         * We already parsed that element
         * ignore it! (yes, this sometimes happens in IE8 when the html is invalid)
         */
        if (oldNode._wysihtml5) {
            return null;
        }
        oldNode._wysihtml5 = 1;

        if (oldNode.className === "wysihtml5-temp") {
            return null;
        }
        var isTableElement = tableElements.indexOf(nodeName) > -1;
        if (!isTableElement && (!oldNode.textContent || !oldNode.textContent.replace(/\n/g, "")) && oldNode.outerHTML.search("<br>") == -1) { //If firstElementChild is not found and firstElement is not a blank line.
            return null;
        }

        if (oldNode.nodeName.toLowerCase() == "li" && !oldNode.textContent.trim()) {
            return null;
        }

        /**
         * IE is the only browser who doesn't include the namespace in the
         * nodeName, that's why we have to prepend it by ourselves
         * scopeName is a proprietary IE feature
         * read more here http://msdn.microsoft.com/en-us/library/ms534388(v=vs.85).aspx
         */
        if (scopeName && scopeName != "HTML") {
            nodeName = scopeName + ":" + nodeName;
        }

        /**
         * Repair node
         * IE is a bit bitchy when it comes to invalid nested markup which includes unclosed tags
         * A <p> doesn't need to be closed according HTML4-5 spec, we simply replace it with a <div> to preserve its content and layout
         */
        if ("outerHTML" in oldNode) {
            if (!wysihtml5.browser.autoClosesUnclosedTags() && oldNode.nodeName === "P" && oldNode.outerHTML.slice(-4).toLowerCase() !== "</p>") {
                nodeName = "div";
            }
        }

        /**
         * Check if currentNode's child is to be removed as per the tagRules
         * and if currentNode's child contains innerHTML data,
         * then assign child's HTML into currentNode's HTML, to remove the child tag
         */
        if (oldNode.hasChildNodes()) {
            var childNodeName = oldNode.firstChild.nodeName.toLowerCase();
            if (childNodeName in tagRules) {
                rule = tagRules[childNodeName];
                if ((!rule || rule.remove) && oldNode.firstChild.innerHTML) {
                    oldNode.innerHTML = oldNode.firstChild.innerHTML;
                }
            }
        }

        if (nodeName in tagRules) {
            rule = tagRules[nodeName];
            if (!rule || rule.remove) {
                return null;
            }

            rule = typeof(rule) === "string" ? {rename_tag : rule} : rule;
        } else if (oldNode.firstChild) {
            rule = {rename_tag : DEFAULT_NODE_NAME};
        } else {
            // Remove empty unknown elements
            return null;
        }

        var listTypes = ["ol", "ul", "dir", "menu"];
        if (listTypes.indexOf(nodeName) >= 0) {
            var children = oldNode.childNodes;
            for (var i = 0; i < children.length; i++) {
                var childNodeName = children[i] && children[i].nodeName.toLowerCase();
                if (childNodeName && (children[i].nodeType == 1 || children[i].nodeType == 3) && children[i].textContent && listTypes.indexOf(childNodeName) == -1 && childNodeName != "li") {
                    var liNode = document.createElement("LI");
                    oldNode.insertBefore(liNode, children[i]);
                    liNode.appendChild(children[i + 1]);
                }
            }
        }

        var listType = _isMSoListParagraphChild(oldNode);
        var validChildCount = _validChildNodeCount(oldNode);
        if (listType && validChildCount) { //Child Element should be greater than two.
            newNode = _convertWordToHTMLNode(oldNode, tagRules);
        } else {
            if (/MsoNormal/i.test(oldNode.className) || (listType && !validChildCount)) { //clean list cache if a para appears after list.
                _cleanUpWordToHTMLCache();
            }
            var renameTag = rule.rename_tag || nodeName;
            if (preProcessingContent) {
                newNode = oldNode.ownerDocument.createElement(renameTag);
            } else {
                var blockElements = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "ol", "ul"];
                var parentNode = oldNode.parentNode;
                while (newParentNodeName && newParentNodeName != "body" && pseudoTags.indexOf(newParentNodeName) > -1) {
                    parentNode = parentNode.parentNode;
                    if (wysihtml5.util.isEditorNode(parentNode)) {
                        newParentNodeName = "body";
                    } else {
                        newParentNodeName = (parentNode && parentNode.nodeName) ? parentNode.nodeName.toLowerCase() : "";
                    }
                }
                if (pseudoTags.indexOf(renameTag) == -1) {
                    //For Table elements create the same new node
                    if (isTableElement) {
                        newNode = oldNode.ownerDocument.createElement(renameTag);
                    } else if (newParentNodeName == "body" && blockElements.indexOf(renameTag) == -1) {
                        newNode = oldNode.ownerDocument.createElement("p");
                    } else if ((newParentNodeName == "ul" || newParentNodeName == "ol") && renameTag != "li" && renameTag != "ol" && renameTag != "ul") {
                        newNode = oldNode.ownerDocument.createElement("li");
                    } else if (newParentNodeName != "body" && newParentNodeName != "li" && ["p", "h1", "h2", "h3", "h4", "h5", "h6"].indexOf(renameTag) > -1) {
                        newNode = oldNode.ownerDocument.createElement("span");
                    } else if ((newParentNodeName != "body" && newParentNodeName != "ol" && newParentNodeName != "ul" && newParentNodeName != "li") && ["ol", "ul", "li"].indexOf(renameTag) > -1) {
                        newNode = oldNode.ownerDocument.createElement("span");
                    } else {
                        newNode = oldNode.ownerDocument.createElement(renameTag);
                    }
                } else {
                    newNode = oldNode.ownerDocument.createElement(renameTag);
                }
            }
            _handleAttributes(oldNode, newNode, rule);
        }

        oldNode = null;
        return newNode;
    }

    function _handleAttributes(oldNode, newNode, rule) {
        var attributes = {},                         // fresh new set of attributes to set on newNode
            setClass = rule.set_class,             // classes to set
            addClass = rule.add_class,             // add classes based on existing attributes
            setAttributes = rule.set_attributes,        // attributes to set on the current node
            checkAttributes = rule.check_attributes,      // check/convert values of attributes
            allowedClasses = currentRules.classes,
            i = 0,
            classes = [],
            newClasses = [],
            newUniqueClasses = [],
            oldClasses = [],
            classesLength,
            newClassesLength,
            currentClass,
            newClass,
            attributeName,
            newAttributeValue,
            method;

        var newNodetagRules = currentRules.tags;
        var newNodeName = newNode ? newNode.nodeName.toLowerCase() : null;
        var newNodeRules;
        if (newNodeName && (newNodeName in newNodetagRules)) {
            newNodeRules = newNodetagRules[newNodeName];
        }
        var removeAttributes = newNodeRules ? newNodeRules.remove_attributes : null; // Remove attributes from old node.

        if (removeAttributes) {
            for (var i = 0; i < removeAttributes.length; i++) {
                var attr = removeAttributes[i];
                if (attr) {
                    var attrArray = attr.split(",");
                    if (attrArray.length == 1) {
                        oldNode.removeAttribute(removeAttributes[i]);
                    } else {
                        var attr = oldNode[attrArray[0]];
                        var childAttr = attr[attrArray[1]];
                        if (childAttr) {
                            if (attrArray.length > 2 && (childAttr.indexOf(attrArray[2]) != -1)) {
                                attr.removeProperty(attrArray[1]);
                            } else if (attrArray.length <= 2) {
                                attr.removeProperty(attrArray[1]);
                            }
                        }
                    }
                }
            }
        }

        if (setAttributes) {
            attributes = wysihtml5.lang.object(setAttributes).clone();
        }

        if (checkAttributes) {
            for (attributeName in checkAttributes) {
                method = attributeCheckMethods[checkAttributes[attributeName]];
                if (!method) {
                    continue;
                }
                newAttributeValue = method(_getAttribute(oldNode, attributeName));
                if (typeof(newAttributeValue) === "string") {
                    attributes[attributeName] = newAttributeValue;
                }
            }
        }

        if (setClass) {
            classes.push(setClass);
        }

        if (addClass) {
            for (attributeName in addClass) {
                method = addClassMethods[addClass[attributeName]];
                if (!method) {
                    continue;
                }
                newClass = method(_getAttribute(oldNode, attributeName));
                if (typeof(newClass) === "string") {
                    classes.push(newClass);
                }
            }
        }

        // make sure that wysihtml5 temp class doesn't get stripped out
        allowedClasses["_wysihtml5-temp-placeholder"] = 1;
        allowedClasses["Apple-tab-span"] = 2;

        // add old classes last
        oldClasses = oldNode.getAttribute("class");
        if (oldClasses) {
            classes = classes.concat(oldClasses.split(WHITE_SPACE_REG_EXP));
        }
        classesLength = classes.length;
        for (i = 0; i < classesLength; i++) {
            currentClass = classes[i];
            if (allowedClasses[currentClass]) {
                newClasses.push(currentClass);
            }
        }

        // remove duplicate entries and preserve class specificity
        newClassesLength = newClasses.length;
        while (newClassesLength--) {
            currentClass = newClasses[newClassesLength];
            if (!wysihtml5.lang.array(newUniqueClasses).contains(currentClass)) {
                newUniqueClasses.unshift(currentClass);
            }
        }

        if (newUniqueClasses.length) {
            attributes["class"] = newUniqueClasses.join(" ");
        }

        // set attributes on newNode
        for (attributeName in attributes) {
            // Setting attributes can cause a js error in IE under certain circumstances
            // eg. on a <img> under https when it's new attribute value is non-https
            // TODO: Investigate this further and check for smarter handling
            try {
                newNode.setAttribute(attributeName, attributes[attributeName]);
            } catch (e) {
            }
        }

        // IE8 sometimes loses the width/height attributes when those are set before the "src"
        // so we make sure to set them again
        if (attributes.src) {
            if (typeof(attributes.width) !== "undefined") {
                newNode.setAttribute("width", attributes.width);
            }
            if (typeof(attributes.height) !== "undefined") {
                newNode.setAttribute("height", attributes.height);
            }
        }

        _copyStyleToNewNode(oldNode, newNode);
        _copyListTypeToNewNode(oldNode, newNode);
        _copyDataAttributeToNewNode(oldNode, newNode);
    }

    function _copyDataAttributeToNewNode(oldNode, newNode) {
        if (oldNode && newNode) {
            var dataset = oldNode.dataset;
            for (var attribute in dataset) {
                $(newNode).data(attribute, dataset[attribute]);
                $(newNode).attr('data-' + attribute, dataset[attribute]);
            }
        }
    }

    function _copyListTypeToNewNode(oldNode, newNode) {
        if (oldNode.nodeName.toLowerCase() == 'ol') {
            var listType = oldNode.getAttribute('type');
            if (listType) {
                newNode.setAttribute('type', listType);
            }
        }
    }

    function _copyStyleToNewNode(oldNode, newNode) {
        var supportedStyles = currentRules.styles;
        var computedStyles = window.getComputedStyle(oldNode),
            appliedStyles = oldNode.style;
        for (var i = 0; i < appliedStyles.length; i++) {
            var styleAttr = appliedStyles[i];
            var value = appliedStyles.getPropertyValue(styleAttr);
            if (supportedStyles.indexOf(styleAttr) >= 0) {
                if (preProcessingContent && styleAttr === "background-color" && value === "rgb(255, 255, 255)") {
                    /* Remove background color if white since its redundant as it is same as default
                    * Fixes bug CQ-4209047 */
                    continue;
                } else {
                    if (!value || !value.match(/^[.\d]+pt$/)) {
                        var value = computedStyles.getPropertyValue(styleAttr) || "";
                        /* Replace all px values to pt*/
                        var regExp = new RegExp("^([.\\d]+)px$", "g");
                        var result = regExp.exec(value);
                        if (result) {
                            var valueInPx = parseFloat(result[1]);
                            var valueInPt = "";
                            if (!isNaN(valueInPx)) {
                                valueInPt = (valueInPx * 0.75) + "pt";
                            }
                            value = value.replace(regExp, valueInPt);
                        }
                    }
                }
                newNode.style.setProperty(styleAttr, value);
            }
        }
    }

    //In firefox, node.childElementCount is childnodes count where childnodes are of element type (Node.ELEMENT_NODE == 1), it does not consider text type node as element node.
    function _validChildNodeCount(oldNode) {
        if (oldNode) {
            var childNodes = oldNode.childNodes;
            var childNode, count = 0;
            for (var i = 0; i < childNodes.length; i++) {
                childNode = childNodes[i];
                if ((childNode.nodeType == 1 || childNode.nodeType == 3) && childNode.textContent && childNode.textContent.trim()) {
                    count++;
                }
            }
            if (count >= 2) {
                return true;
            }
        }
        return false;
    }

    // Bug Fix - CQ-95130. In listing extra space is added. Removing all extra space from just before and after node of type determining
    // node of Mso list.
    function _removeExtraSpace(oldNode, typeDeterminigNode) {
        var childNodes = oldNode.childNodes;
        var childNode, i;
        if (!wysihtml5.browser.isFireFox) {
            for (i = 0; childNodes[i] != typeDeterminigNode; i++) {
                childNode = childNodes[i];
                if (childNode && childNode.textContent) {
                    childNode.textContent = childNode.textContent.trim();
                }
            }
            i++; // Just next node to List type determining node
            childNode = childNodes[i];
            if (childNode && childNode.textContent) {
                childNode.textContent = childNode.textContent.trim();
            }
        }
        return oldNode;
    }

    function _convertWordToHTMLNode(oldNode, tagRules) {
        if (oldNode) {
            /* check if its MsoListParagraph then create li and if its MsoListParagraphCxSpFirst then convert to OL or UL
             * OL or UL is decided based on first Span content
             */
            if (/MsoListParagraph/i.test(oldNode.className)) {
                var isNewContainer = _setCurrentListElement(oldNode);
                // Create LI and copy the child of old node to new LI node using rule written for parsing
                var element = oldNode.ownerDocument.createElement("li"),
                    oldFontFamily = oldNode.firstElementChild.style.fontFamily,
                    fontFamilyList = Array.from($("#textEditor_fontFamily_container coral-select-item")).map(function (item) {
                        return item.value;
                    });
                // Check if copied font-family is preset in rte-editor font list, add font-family to li element
                if (oldFontFamily != null && fontFamilyList.includes(oldFontFamily.split(",")[0])) {
                    element.style.fontFamily = oldFontFamily;
                }
                var paraElement = oldNode.ownerDocument.createElement("p");
                if (oldNode.firstChild) {
                    var newNode = null, firstChild = null;
                    firstChild = _getTextChildNode(oldNode);
                    oldNode = _removeExtraSpace(oldNode, firstChild); // Remove extra space from list.
                    firstChild = _getTextChildNode(oldNode);
                    if (firstChild) {
                        oldNode.removeChild(firstChild);
                    } // Remove the firstChild which hold the Bullet or number type
                    while (oldNode.firstChild) {
                        firstChild = oldNode.firstChild;
                        newNode = _convert(firstChild, true, "p");
                        oldNode.removeChild(firstChild);
                        if (newNode) {
                            paraElement.appendChild(newNode);
                        }
                    }
                    element.appendChild(paraElement);
                }
                if (currentListElement) {
                    currentListElement.appendChild(element);
                }

                if (isNewContainer) {
                    return currentListElement;
                }
            }
        }
        return null;
    }

    var currentListElement = null;
    var levelListMap = {}; // This map will hold the Container ( OL or UL ) for each level ( multi-level listing)
    var MS_LEVEL1 = "level1";

    function _setCurrentListElement(oldNode) {
        if (oldNode) {
            var container = _createListContainer(oldNode);
            var listProperty = _getCustomCssProperty(oldNode, "mso-list");
            listProperty = listProperty ? listProperty.split(" ") : [];
            var listLevel = listProperty && listProperty.length >= 2 ? listProperty[1] : MS_LEVEL1;
            /* Create a OL or UL in following case
             * a    if currentListElement is not found in the map ( first LI)
             * b    else if bullet or number type is changed in middle
             */
            if (levelListMap.hasOwnProperty(listLevel)) {// container is available in levelListMap
                currentListElement = levelListMap[listLevel];
            }
            if (!currentListElement || (container && (currentListElement.type != container.type || !levelListMap.hasOwnProperty(listLevel)))) { // 2nd condition is if list type change or compound list then create new container
                if (MS_LEVEL1 == listLevel) {
                    levelListMap = {};
                } // If its level 1 then rest the Map
                else if (currentListElement && currentListElement.lastElementChild) {// if next level is starting then add new container to parent List container
                    currentListElement.lastElementChild.appendChild(container);
                }
                levelListMap[listLevel] = container;
                currentListElement = container;
            }
            if (MS_LEVEL1 == listLevel) {
                return true;
            } // send true if first level container is added as it need to be added in DOM other level container will be directly added to parent list container
        }
        return false;
    }

    function _cleanUpWordToHTMLCache() {
        levelListMap = {};
        currentListElement = null;
    }

    function _createListContainer(oldNode) {
        var element = null;
        if (oldNode) {
            if (/MsoListParagraph/i.test(oldNode.className)) {
                var textNode = _getTextChildNode(oldNode);
                if (textNode) {
                    var textContent = textNode.textContent ? textNode.textContent.trim() : "";
                    var splitArray = textContent.split(".");
                    if ((splitArray.length - 2) >= 0) {
                        textContent = splitArray[splitArray.length - 2];
                    }
                    var type = textContent ? _getListContainerType(textContent) : null;
                    if (type) {// Check type of content in firstSpan ( which contains bullet or number type)
                        var elementName = /disc|circle|square/.test(type) ? "ul" : "ol";
                        element = oldNode.ownerDocument.createElement(elementName);
                        element.type = type;
                    } else {// if type is not recognized then created UL with type disc
                        element = oldNode.ownerDocument.createElement("ul");
                        element.type = "disc";
                    }
                }
            }
        }
        return element;
    }

    function checkForAlphabetList(textContent, currentListElement) {
        if (currentListElement && (currentListElement.type == "a" || currentListElement.type == "A")) {
            var alphabet = "abcdefghijklmnopqrstuvwxyz";
            var characterInAlphabetSet = alphabet.charAt(currentListElement.childElementCount);
            if (currentListElement.type == "A") {
                characterInAlphabetSet = alphabet.toUpperCase().charAt(currentListElement.childElementCount);
            }
            if (textContent == characterInAlphabetSet) {
                return currentListElement.type;
            }
        }
        if (currentListElement && currentListElement.parentElement && currentListElement.parentElement.parentElement) {
            return checkForAlphabetList(textContent, currentListElement.parentElement.parentElement);
        }
    }

    function checkForNumericList(textContent, currentListElement) {
        if (currentListElement && (currentListElement.type == "1")) {
            var childElements = currentListElement.childElementCount;
            var decimalValue = parseInt(textContent);
            if (childElements + 1 == decimalValue) {
                return currentListElement.type;
            }
        }
        if (currentListElement && currentListElement.parentElement && currentListElement.parentElement.parentElement) {
            return checkForNumericList(textContent, currentListElement.parentElement.parentElement);
        }
    }

    function checkForRomanList(textContent, currentListElement) {
        if (currentListElement && (currentListElement.type == "i" || currentListElement.type == "I")) {
            var childElements = currentListElement.childElementCount;
            var romanValue = _getRomanToDecimal(textContent);

            if (childElements + 1 == romanValue) {
                if ((textContent[0].toUpperCase() == textContent[0]) && (currentListElement.type == "I")) {
                    return currentListElement.type;
                } else if ((textContent[0].toLowerCase() == textContent[0]) && (currentListElement.type == "i")) {
                    return currentListElement.type;
                }
            }
        }
        if (currentListElement && currentListElement.parentElement && currentListElement.parentElement.parentElement) {
            return checkForRomanList(textContent, currentListElement.parentElement.parentElement);
        }

    }

    function _getIntegerValue(romanChar) {
        var romArr = ["i", "v", "x", "l", "c", "d", "m"];
        var intArr = [1, 5, 10, 50, 100, 500, 1000];
        return intArr[romArr.indexOf(romanChar)];
    }

    function _getRomanToDecimal(str) {
        var res = 0, romanFirstVal, romanSecondVal;
        var lowerRomanTypeReg = /^m{0,4}(cm|cd|d?c{0,3})(xc|xl|l?x{0,3})(ix|iv|v?i{0,3})$/;
        if (str.toLowerCase().match(lowerRomanTypeReg)) {
            for (var i = 0; i < str.length; i++) {
                romanFirstVal = _getIntegerValue(str[i].toLowerCase());
                if (i + 1 < str.length) {
                    romanSecondVal = _getIntegerValue(str[i + 1].toLowerCase());
                    if (romanFirstVal >= romanSecondVal) {
                        res = res + romanFirstVal;
                    } else {
                        res = res + romanSecondVal - romanFirstVal;
                        i++;
                    }
                } else {
                    res = res + romanFirstVal;
                    i++;
                }
            }
            return res;
        }
    }

    function _getListContainerType(textContentStr) {
        var decimalTypeReg = /\d+/,
            lowerRomanTypeReg = /^m{0,4}(cm|cd|d?c{0,3})(xc|xl|l?x{0,3})(ix|iv|v?i{0,3})$/,
            upperRomanTypeReg = /^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/,
            lowerAlphaTypeReg = /^[a-z]+$/,
            upperAlphaTypeReg = /^[A-Z]+$/;
        var discTypeReg = /[l\u00B7\u2002]/,
            circleTypeReg = /[\u006F\u00D8]/,
            squareTypeReg = /[\u006E\u25C6\u00A7]/;

        var validAlphabet = false, validRoman = false, validInteger = false;
        if (textContentStr) {
            if (textContentStr.toLowerCase().match(lowerRomanTypeReg)) {
                validRoman = true;
            }
            if (textContentStr.toLowerCase().match(lowerAlphaTypeReg)) {
                validAlphabet = true;
            }
            if (textContentStr.match(decimalTypeReg)) {
                validInteger = true;
            }
        }

        var romanList = validRoman ? checkForRomanList(textContentStr, currentListElement) : null;
        if (romanList) {
            return romanList;
        }

        var textContent = textContentStr.substr(0, 1);
        var alphaList = validAlphabet ? checkForAlphabetList(textContent, currentListElement) : null;
        if (alphaList) {
            return alphaList;
        }

        var numericList = validInteger ? checkForNumericList(textContentStr, currentListElement) : null;
        if (numericList) {
            return numericList;
        }

        if (textContentStr && (textContentStr == "a" || textContentStr == "A" || textContentStr == "i" || textContentStr == "I" || textContentStr == "1")) {
            return textContentStr;
        } else if (textContent.match(discTypeReg)) {
            return "disc";
        } else if (textContent.match(circleTypeReg)) {
            return "circle";
        } else if (textContent.match(squareTypeReg)) {
            return "square";
        }
        return null;
    }

    // Action on  MSO List node which first text node has list type information.
    function _getTextChildNode(oldNode) {
        if (oldNode) {
            var childNodes = oldNode.childNodes;
            var textContent, childNode;
            for (var i = 0; i < childNodes.length; i++) {
                childNode = childNodes[i];
                textContent = childNode.textContent ? childNode.textContent.trim() : "";
                if (childNode && (childNode.nodeType == 3 || childNode.nodeType == 1) && textContent) {
                    return childNode;
                }
            }
        }
    }

    function _isMSoListParagraphChild(oldNode) {
        // Since each and very element is passed why parser check if any element is part of MsoListParagraph if so ignore it as its already handle via creating LI
        if (oldNode) {
            if (/MsoListParagraph/i.test(oldNode.className)) {
                return true;
            }
        }
        return false;
    }

    function _getCustomCssProperty(element, propertyName) {
        if (element) {
            var style = element.getAttribute("style");
            var entries = style.split(";");

            for (var i = 0;
                 i < entries.length;
                 i++) {
                var entry = entries[i].split(":");
                if (entry[0] == propertyName) {
                    return entry[1];
                }
            }
        }
        return null;
    }

    /**
     * IE gives wrong results for hasAttribute/getAttribute, for example:
     *    var td = document.createElement("td");
     *    td.getAttribute("rowspan"); // => "1" in IE
     *
     * Therefore we have to check the element's outerHTML for the attribute
     */
    var HAS_GET_ATTRIBUTE_BUG = !wysihtml5.browser.supportsGetAttributeCorrectly();

    function _getAttribute(node, attributeName) {
        attributeName = attributeName.toLowerCase();
        var nodeName = node.nodeName;
        if (nodeName == "IMG" && attributeName == "src" && _isLoadedImage(node) === true) {
            // Get 'src' attribute value via object property since this will always contain the
            // full absolute url (http://...)
            // this fixes a very annoying bug in firefox (ver 3.6 & 4) and IE 8 where images copied from the same host
            // will have relative paths, which the sanitizer strips out (see attributeCheckMethods.url)
            return node.src;
        } else if (HAS_GET_ATTRIBUTE_BUG && "outerHTML" in node) {
            // Don't trust getAttribute/hasAttribute in IE 6-8, instead check the element's outerHTML
            var outerHTML = node.outerHTML.toLowerCase(),
                // TODO: This might not work for attributes without value: <input disabled>
                hasAttribute = outerHTML.indexOf(" " + attributeName + "=") != -1;

            return hasAttribute ? node.getAttribute(attributeName) : null;
        } else {
            return node.getAttribute(attributeName);
        }
    }

    /**
     * Check whether the given node is a proper loaded image
     * FIXME: Returns undefined when unknown (Chrome, Safari)
     */
    function _isLoadedImage(node) {
        try {
            return node.complete && !node.mozMatchesSelector(":-moz-broken");
        } catch (e) {
            if (node.complete && node.readyState === "complete") {
                return true;
            }
        }
    }

    function _handleText(oldNode) {
        return oldNode.ownerDocument.createTextNode(oldNode.data);
    }

    // ------------ attribute checks ------------ \\
    var attributeCheckMethods = {
        any : (function () {
            return function (attributeValue) {
                return attributeValue;
            };
        })(),

        url : (function () {
            var REG_EXP = /^https?:\/\//i;
            return function (attributeValue) {
                if (!attributeValue || !attributeValue.match(REG_EXP)) {
                    return null;
                }
                return attributeValue.replace(REG_EXP, function (match) {
                    return match.toLowerCase();
                });
            };
        })(),

        src : (function () {
            var REG_EXP = /^(\/|https?:\/\/)/i;
            return function (attributeValue) {
                if (!attributeValue || !attributeValue.match(REG_EXP)) {
                    return null;
                }
                return attributeValue.replace(REG_EXP, function (match) {
                    return match.toLowerCase();
                });
            };
        })(),

        href : (function () {
            var REG_EXP = /^(\/|https?:\/\/|mailto:)/i;
            return function (attributeValue) {
                if (!attributeValue || !attributeValue.match(REG_EXP)) {
                    return null;
                }
                return attributeValue.replace(REG_EXP, function (match) {
                    return match.toLowerCase();
                });
            };
        })(),

        alt : (function () {
            var REG_EXP = /[^ a-z0-9_\-]/gi;
            return function (attributeValue) {
                if (!attributeValue) {
                    return "";
                }
                return attributeValue.replace(REG_EXP, "");
            };
        })(),

        numbers : (function () {
            var REG_EXP = /\D/g;
            return function (attributeValue) {
                attributeValue = (attributeValue || "").replace(REG_EXP, "");
                return attributeValue || null;
            };
        })()
    };

    // ------------ class converter (converts an html attribute to a class name) ------------ \\
    var addClassMethods = {
        align_img : (function () {
            var mapping = {
                left : "wysiwyg-float-left",
                right : "wysiwyg-float-right"
            };
            return function (attributeValue) {
                return mapping[String(attributeValue).toLowerCase()];
            };
        })(),

        align_text : (function () {
            var mapping = {
                left : "wysiwyg-text-align-left",
                right : "wysiwyg-text-align-right",
                center : "wysiwyg-text-align-center",
                justify : "wysiwyg-text-align-justify"
            };
            return function (attributeValue) {
                return mapping[String(attributeValue).toLowerCase()];
            };
        })(),

        clear_br : (function () {
            var mapping = {
                left : "wysiwyg-clear-left",
                right : "wysiwyg-clear-right",
                both : "wysiwyg-clear-both",
                all : "wysiwyg-clear-both"
            };
            return function (attributeValue) {
                return mapping[String(attributeValue).toLowerCase()];
            };
        })(),

        size_font : (function () {
            var mapping = {
                "1" : "wysiwyg-font-size-xx-small",
                "2" : "wysiwyg-font-size-small",
                "3" : "wysiwyg-font-size-medium",
                "4" : "wysiwyg-font-size-large",
                "5" : "wysiwyg-font-size-x-large",
                "6" : "wysiwyg-font-size-xx-large",
                "7" : "wysiwyg-font-size-xx-large",
                "-" : "wysiwyg-font-size-smaller",
                "+" : "wysiwyg-font-size-larger"
            };
            return function (attributeValue) {
                return mapping[String(attributeValue).charAt(0)];
            };
        })()
    };

    return parse;
})();
/**
 * Checks for empty text node childs and removes them
 *
 * @param {Element} node The element in which to cleanup
 * @example
 *    wysihtml5.dom.removeEmptyTextNodes(element);
 */
wysihtml5.dom.removeEmptyTextNodes = function (node) {
    var childNode,
        childNodes = wysihtml5.lang.array(node.childNodes).get(),
        childNodesLength = childNodes.length,
        i = 0;
    for (;
        i < childNodesLength;
        i++) {
        childNode = childNodes[i];
        if (childNode.nodeType === wysihtml5.TEXT_NODE && childNode.data === "") {
            childNode.parentNode.removeChild(childNode);
        }
    }
};
/**
 * Renames an element (eg. a <div> to a <p>) and keeps its childs
 *
 * @param {Element} element The list element which should be renamed
 * @param {Element} newNodeName The desired tag name
 *
 * @example
 *    <!-- Assume the following dom: -->
 *    <ul id="list">
 *      <li>eminem</li>
 *      <li>dr. dre</li>
 *      <li>50 Cent</li>
 *    </ul>
 *
 *    <script>
 *      wysihtml5.dom.renameElement(document.getElementById("list"), "ol");
 *    </script>
 *
 *    <!-- Will result in: -->
 *    <ol>
 *      <li>eminem</li>
 *      <li>dr. dre</li>
 *      <li>50 Cent</li>
 *    </ol>
 */
wysihtml5.dom.renameElement = function (element, newNodeName) {
    var newElement = element.ownerDocument.createElement(newNodeName),
        firstChild;
    while (firstChild = element.firstChild) {
        newElement.appendChild(firstChild);
    }
    wysihtml5.dom.copyAttributes(["align", "className"]).from(element).to(newElement);
    //wysihtml5.dom.copyStyles(["line-height"]).from(element).to(newElement);
    element.parentNode.replaceChild(newElement, element);
    return newElement;
};
/**
 * Takes an element, removes it and replaces it with it's childs
 *
 * @param {Object} node The node which to replace with it's child nodes
 * @example
 *    <div id="foo">
 *      <span>hello</span>
 *    </div>
 *    <script>
 *      // Remove #foo and replace with it's children
 *      wysihtml5.dom.replaceWithChildNodes(document.getElementById("foo"));
 *    </script>
 */
wysihtml5.dom.replaceWithChildNodes = function (node) {
    if (!node.parentNode) {
        return;
    }

    if (!node.firstChild) {
        node.parentNode.removeChild(node);
        return;
    }

    var fragment = node.ownerDocument.createDocumentFragment();
    while (node.firstChild) {
        fragment.appendChild(node.firstChild);
    }
    node.parentNode.replaceChild(fragment, node);
    node = fragment = null;
};
/**
 * Unwraps an unordered/ordered list
 *
 * @param {Element} element The list element which should be unwrapped
 *
 * @example
 *    <!-- Assume the following dom: -->
 *    <ul id="list">
 *      <li>eminem</li>
 *      <li>dr. dre</li>
 *      <li>50 Cent</li>
 *    </ul>
 *
 *    <script>
 *      wysihtml5.dom.resolveList(document.getElementById("list"));
 *    </script>
 *
 *    <!-- Will result in: -->
 *    eminem<br>
 *    dr. dre<br>
 *    50 Cent<br>
 */
(function (dom) {
    function _isBlockElement(node) {
        return dom.getStyle("display").from(node) === "block";
    }

    function _isLineBreak(node) {
        return node.nodeName === "BR";
    }

    function _appendLineBreak(element) {
        var lineBreak = element.ownerDocument.createElement("br");
        element.appendChild(lineBreak);
    }

    function resolveList(list, useLineBreaks) {
        if (!list.nodeName.match(/^(MENU|UL|OL)$/)) {
            return;
        }

        var doc = list.ownerDocument,
            fragment = doc.createDocumentFragment(),
            previousSibling = list.previousElementSibling || list.previousSibling,
            firstChild,
            lastChild,
            isLastChild,
            shouldAppendLineBreak,
            paragraph,
            listItem;

        if (useLineBreaks) {
            // Insert line break if list is after a non-block element
            if (previousSibling && !_isBlockElement(previousSibling)) {
                _appendLineBreak(fragment);
            }

            while (listItem = (list.firstElementChild || list.firstChild)) {
                lastChild = listItem.lastChild;
                while (firstChild = listItem.firstChild) {
                    isLastChild = firstChild === lastChild;
                    // This needs to be done before appending it to the fragment, as it otherwise will lose style information
                    shouldAppendLineBreak = isLastChild && !_isBlockElement(firstChild) && !_isLineBreak(firstChild);
                    fragment.appendChild(firstChild);
                    if (shouldAppendLineBreak) {
                        _appendLineBreak(fragment);
                    }
                }

                listItem.parentNode.removeChild(listItem);
            }
        } else {
            while (listItem = (list.firstElementChild || list.firstChild)) {
                if (listItem.querySelector && listItem.querySelector("div, p, ul, ol, menu, blockquote, h1, h2, h3, h4, h5, h6")) {
                    while (firstChild = listItem.firstChild) {
                        fragment.appendChild(firstChild);
                    }
                } else {
                    paragraph = doc.createElement("p");
                    while (firstChild = listItem.firstChild) {
                        paragraph.appendChild(firstChild);
                    }
                    fragment.appendChild(paragraph);
                }
                listItem.parentNode.removeChild(listItem);
            }
        }

        list.parentNode.replaceChild(fragment, list);
    }

    dom.resolveList = resolveList;
})(wysihtml5.dom);
/**
 * Sandbox for executing javascript, parsing css styles and doing dom operations in a secure way
 *
 * Browser Compatibility:
 *  - Secure in MSIE 6+, but only when the user hasn't made changes to his security level "restricted"
 *  - Partially secure in other browsers (Firefox, Opera, Safari, Chrome, ...)
 *
 * Please note that this class can't benefit from the HTML5 sandbox attribute for the following reasons:
 *    - sandboxing doesn't work correctly with inlined content (src="javascript:'<html>...</html>'")
 *    - sandboxing of physical documents causes that the dom isn't accessible anymore from the outside (iframe.contentWindow, ...)
 *    - setting the "allow-same-origin" flag would fix that, but then still javascript and dom events refuse to fire
 *    - therefore the "allow-scripts" flag is needed, which then would deactivate any security, as the js executed inside the iframe
 *      can do anything as if the sandbox attribute wasn't set
 *
 * @param {Function} [readyCallback] Method that gets invoked when the sandbox is ready
 * @param {Object} [config] Optional parameters
 *
 * @example
 *    new wysihtml5.dom.Sandbox(function(sandbox) {
 *      sandbox.getWindow().document.body.innerHTML = '<img src=foo.gif onerror="alert(document.cookie)">';
 *    });
 */
(function (wysihtml5) {
    var /**
         * Default configuration
         */
        doc = document,
        /**
         * Properties to unset/protect on the window object
         */
        windowProperties = [
            "parent", "top", "opener", "frameElement", "frames",
            "localStorage", "globalStorage", "sessionStorage", "indexedDB"
        ],
        /**
         * Properties on the window object which are set to an empty function
         */
        windowProperties2 = [
            "open", "close", "openDialog", "showModalDialog",
            "alert", "confirm", "prompt",
            "openDatabase", "postMessage",
            "XMLHttpRequest", "XDomainRequest"
        ],
        /**
         * Properties to unset/protect on the document object
         */
        documentProperties = [
            "referrer",
            "write", "open", "close"
        ];

    wysihtml5.dom.Sandbox = Base.extend(
        /** @scope wysihtml5.dom.Sandbox.prototype */ {

            constructor : function (config) {
                this.config = wysihtml5.lang.object({}).merge(config).get();
                this.container = this._createContainer();
            },

            insertInto : function (element) {
                if (typeof(element) === "string") {
                    element = doc.getElementById(element);
                }

                element.appendChild(this.container);
            },

            getContainer : function () {
                return this.container;
            },

            getWindow : function () {
                this._readyError();
            },

            getDocument : function () {
                this._readyError();
            },

            destroy : function () {
                var container = this.getContainer();
                if (container && container.parentNode) {
                    container.parentNode.removeChild(container);
                }
            },

            _readyError : function () {
                throw new Error("wysihtml5.Sandbox: Sandbox container isn't loaded yet");
            },

            /**
             * Creates the sandbox container
             *
             * Some important notes:
             *  - We can't use HTML5 sandbox for now:
             *    setting it causes that the iframe's dom can't be accessed from the outside
             *    Therefore we need to set the "allow-same-origin" flag which enables accessing the iframe's dom
             *    But then there's another problem, DOM events (focus, blur, change, keypress, ...) aren't fired.
             *    In order to make this happen we need to set the "allow-scripts" flag.
             *    A combination of allow-scripts and allow-same-origin is almost the same as setting no sandbox attribute at all.
             *  - Chrome & Safari, doesn't seem to support sandboxing correctly when the iframe's html is inlined (no physical document)
             *  - IE needs to have the security="restricted" attribute set before the iframe is
             *    inserted into the dom tree
             *  - Believe it or not but in IE "security" in document.createElement("iframe") is false, even
             *    though it supports it
             *  - When an iframe has security="restricted", in IE eval() & execScript() don't work anymore
             *  - IE doesn't fire the onload event when the content is inlined in the src attribute, therefore we rely
             *    on the onreadystatechange event
             */
            _createContainer : function () {
                var container = doc.createElement("div");
                this.getWindow = function () {
                    var doc = this.getDocument();
                    return doc.defaultView || doc.parentWindow;
                };
                this.getDocument = function () {
                    return container.ownerDocument;
                };

                return container;
            },

            _getHtml : function (templateVars) {
                var stylesheets = templateVars.stylesheets,
                    html = "",
                    i = 0,
                    length;
                stylesheets = typeof(stylesheets) === "string" ? [stylesheets] : stylesheets;
                if (stylesheets) {
                    length = stylesheets.length;
                    for (;
                        i < length;
                        i++) {
                        html += '<link rel="stylesheet" href="' + stylesheets[i] + '">';
                    }
                }
                templateVars.stylesheets = html;

                return wysihtml5.lang.string(
                    '<!DOCTYPE html><html><head>' +
                    '<meta charset="#{charset}">#{stylesheets}</head>' +
                    '<body></body></html>'
                ).interpolate(templateVars);
            },

            /**
             * Method to unset/override existing variables
             * @example
             *    // Make cookie unreadable and unwritable
             *    this._unset(document, "cookie", "", true);
             */
            _unset : function (object, property, value, setter) {
                try {
                    object[property] = value;
                } catch (e) {
                }

                try {
                    object.__defineGetter__(property, function () {
                        return value;
                    });
                } catch (e) {
                }
                if (setter) {
                    try {
                        object.__defineSetter__(property, function () {
                        });
                    } catch (e) {
                    }
                }

                if (!wysihtml5.browser.crashesWhenDefineProperty(property)) {
                    try {
                        var config = {
                            get : function () {
                                return value;
                            }
                        };
                        if (setter) {
                            config.set = function () {
                            };
                        }
                        Object.defineProperty(object, property, config);
                    } catch (e) {
                    }
                }
            }
        });
})(wysihtml5);
(function () {
    var mapping = {
        "className" : "class"
    };
    wysihtml5.dom.setAttributes = function (attributes) {
        return {
            on : function (element) {
                for (var i in attributes) {
                    element.setAttribute(mapping[i] || i, attributes[i]);
                }
            }
        };
    };
})();
wysihtml5.dom.setStyles = function (styles) {
    return {
        on : function (element) {
            var style = element.style;
            if (typeof(styles) === "string") {
                style.cssText += ";" + styles;
                return;
            }
            for (var i in styles) {
                if (i === "float") {
                    style.cssFloat = styles[i];
                    style.styleFloat = styles[i];
                } else {
                    style[i] = styles[i];
                }
            }
        }
    };
};
/**
 * Simulate HTML5 placeholder attribute
 *
 * Needed since
 *    - div[contentEditable] elements don't support it
 *    - older browsers (such as IE8 and Firefox 3.6) don't support it at all
 *
 * @param {Object} parent Instance of main wysihtml5.Editor class
 * @param {Element} view Instance of wysihtml5.views.* class
 * @param {String} placeholderText
 *
 * @example
 *    wysihtml.dom.simulatePlaceholder(this, composer, "Foobar");
 */
(function (dom) {
    dom.simulatePlaceholder = function (editor, view, placeholderText) {
        var CLASS_NAME = "placeholder",
            unset = function () {
                if (view.hasPlaceholderSet()) {
                    view.clear();
                }
                view.placeholderSet = false;
                dom.removeClass(view.element, CLASS_NAME);
            },
            set = function () {
                if (view.isEmpty()) {
                    view.placeholderSet = true;
                    view.setValue(placeholderText);
                    dom.addClass(view.element, CLASS_NAME);
                }
            };

        editor
            .on("set_placeholder", set)
            .on("unset_placeholder", unset)
            .on("focus:composer", unset)
            .on("click:composer", unset)
            .on("paste:composer", unset)
            .on("blur:composer", set);

        set();
    };
})(wysihtml5.dom);
(function (dom) {
    var documentElement = document.documentElement;
    if ("textContent" in documentElement) {
        dom.setTextContent = function (element, text) {
            element.textContent = text;
        };

        dom.getTextContent = function (element) {
            return element.textContent;
        };
    } else if ("innerText" in documentElement) {
        dom.setTextContent = function (element, text) {
            element.innerText = text;
        };

        dom.getTextContent = function (element) {
            return element.innerText;
        };
    } else {
        dom.setTextContent = function (element, text) {
            element.nodeValue = text;
        };

        dom.getTextContent = function (element) {
            return element.nodeValue;
        };
    }
})(wysihtml5.dom);

/**
 * Fix most common html formatting misbehaviors of browsers implementation when inserting
 * content via copy & paste contentEditable
 *
 * @author Christopher Blum
 */
wysihtml5.quirks.cleanPastedHTML = (function () {
    // TODO: We probably need more rules here
    var defaultRules = {
        // When pasting underlined links <a> into a contentEditable, IE thinks, it has to insert <u> to keep the styling
        "a u" : wysihtml5.dom.replaceWithChildNodes
    };

    function cleanPastedHTML(elementOrHtml, rules, context) {
        rules = rules || defaultRules;
        context = context || elementOrHtml.ownerDocument || document;

        var element,
            isString = typeof(elementOrHtml) === "string",
            method,
            matches,
            matchesLength,
            i,
            j = 0;
        if (isString) {
            element = wysihtml5.dom.getAsDom(elementOrHtml, context);
        } else {
            element = elementOrHtml;
        }

        for (i in rules) {
            matches = element.querySelectorAll(i);
            method = rules[i];
            matchesLength = matches.length;
            for (;
                j < matchesLength;
                j++) {
                method(matches[j]);
            }
        }

        matches = elementOrHtml = rules = null;

        return isString ? element.innerHTML : element;
    }

    return cleanPastedHTML;
})();
/**
 * IE and Opera leave an empty paragraph in the contentEditable element after clearing it
 *
 * @param {Object} contentEditableElement The contentEditable element to observe for clearing events
 * @exaple
 *    wysihtml5.quirks.ensureProperClearing(myContentEditableElement);
 */
wysihtml5.quirks.ensureProperClearing = (function () {
    var clearIfNecessary = function () {
        var element = this;
        setTimeout(function () {
            var innerHTML = element.innerHTML.toLowerCase();
            if (innerHTML == "<p>&nbsp;</p>" ||
                innerHTML == "<p>&nbsp;</p><p>&nbsp;</p>") {
                element.innerHTML = "";
            }
        }, 0);
    };

    return function (composer) {
        wysihtml5.dom.observe(composer.element, ["cut", "keydown"], clearIfNecessary);
    };
})();
// See https://bugzilla.mozilla.org/show_bug.cgi?id=664398
//
// In Firefox this:
//      var d = document.createElement("div");
//      d.innerHTML ='<a href="~"></a>';
//      d.innerHTML;
// will result in:
//      <a href="%7E"></a>
// which is wrong
(function (wysihtml5) {
    var TILDE_ESCAPED = "%7E";
    wysihtml5.quirks.getCorrectInnerHTML = function (element) {
        var innerHTML = element.innerHTML;
        if (innerHTML.indexOf(TILDE_ESCAPED) === -1) {
            return innerHTML.trim();
        }

        var elementsWithTilde = element.querySelectorAll("[href*='~'], [src*='~']"),
            url,
            urlToSearch,
            length,
            i;
        for (i = 0, length = elementsWithTilde.length;
             i < length;
             i++) {
            url = elementsWithTilde[i].href || elementsWithTilde[i].src;
            urlToSearch = wysihtml5.lang.string(url).replace("~").by(TILDE_ESCAPED);
            innerHTML = wysihtml5.lang.string(innerHTML).replace(urlToSearch).by(url);
        }
        return innerHTML;
    };
})(wysihtml5);
/**
 * Force rerendering of a given element
 * Needed to fix display misbehaviors of IE
 *
 * @param {Element} element The element object which needs to be rerendered
 * @example
 *    wysihtml5.quirks.redraw(document.body);
 */
(function (wysihtml5) {
    var CLASS_NAME = "wysihtml5-quirks-redraw";

    wysihtml5.quirks.redraw = function (element) {
        wysihtml5.dom.addClass(element, CLASS_NAME);
        wysihtml5.dom.removeClass(element, CLASS_NAME);

        // Following hack is needed for firefox to make sure that image resize handles are properly removed
        try {
            var doc = element.ownerDocument;
            doc.execCommand("italic", false, null);
            doc.execCommand("italic", false, null);
        } catch (e) {
        }
    };
})(wysihtml5);
/**
 * Selection API
 *
 * @example
 *    var selection = new wysihtml5.Selection(editor);
 */
(function (wysihtml5) {
    var dom = wysihtml5.dom;

    function _getCumulativeOffsetTop(element) {
        var top = 0;
        if (element.parentNode) {
            do {
                top += element.offsetTop || 0;
                element = element.offsetParent;
            } while (element);
        }
        return top;
    }

    wysihtml5.Selection = Base.extend(
        /** @scope wysihtml5.Selection.prototype */ {
            constructor : function (editor) {
                // Make sure that our external range library is initialized
                window.rangy.init();

                this.editor = editor;
                this.composer = editor.composer;
                this.doc = this.composer.doc;
            },

            /**
             * Get the current selection as a bookmark to be able to later restore it
             *
             * @return {Object} An object that represents the current selection
             */
            getBookmark : function () {
                var range = this.getRange();
                return range && range.cloneRange();
            },

            /**
             * Restore a selection retrieved via wysihtml5.Selection.prototype.getBookmark
             *
             * @param {Object} bookmark An object that represents the current selection
             */
            setBookmark : function (bookmark) {
                if (!bookmark) {
                    return;
                }

                this.setSelection(bookmark);
            },

            /**
             * Set the caret in front of the given node
             *
             * @param {Object} node The element or text node where to position the caret in front of
             * @example
             *    selection.setBefore(myElement);
             */
            setBefore : function (node) {
                var range = rangy.createRange(this.doc);
                range.setStartBefore(node);
                range.setEndBefore(node);
                return this.setSelection(range);
            },

            /**
             * Set the caret after the given node
             *
             * @param {Object} node The element or text node where to position the caret in front of
             * @example
             *    selection.setBefore(myElement);
             */
            setAfter : function (node) {
                var range = rangy.createRange(this.doc);
                range.setStartAfter(node);
                range.setEndAfter(node);
                return this.setSelection(range);
            },

            /**
             * Ability to select/mark nodes
             *
             * @param {Element} node The node/element to select
             * @example
             *    selection.selectNode(document.getElementById("my-image"));
             */
            selectNode : function (node, avoidInvisibleSpace) {
                var range = rangy.createRange(this.doc),
                    isElement = node.nodeType === wysihtml5.ELEMENT_NODE,
                    canHaveHTML = "canHaveHTML" in node ? node.canHaveHTML : (node.nodeName !== "IMG"),
                    content = isElement ? node.innerHTML : node.data,
                    isEmpty = (content === "" || content === wysihtml5.INVISIBLE_SPACE),
                    displayStyle = dom.getStyle("display").from(node),
                    isBlockElement = (displayStyle === "block" || displayStyle === "list-item");

                if (isEmpty && isElement && canHaveHTML && !avoidInvisibleSpace) {
                    // Make sure that caret is visible in node by inserting a zero width no breaking space
                    try {
                        node.innerHTML = wysihtml5.INVISIBLE_SPACE;
                    } catch (e) {
                    }
                }

                if (canHaveHTML) {
                    range.selectNodeContents(node);
                } else {
                    range.selectNode(node);
                }

                if (canHaveHTML && isEmpty && isElement) {
                    range.collapse(isBlockElement);
                } else if (canHaveHTML && isEmpty) {
                    range.setStartAfter(node);
                    range.setEndAfter(node);
                }

                this.setSelection(range);
            },

            /**
             * Get the node which contains the selection
             *
             * @param {Boolean} [controlRange] (only IE) Whether it should return the selected ControlRange element when the selection type is a "ControlRange"
             * @return {Object} The node that contains the caret
             * @example
             *    var nodeThatContainsCaret = selection.getSelectedNode();
             */
            getSelectedNode : function (controlRange, excludeEditorContainer) {
                var selection,
                    range,
                    selectedNode = null;

                if (controlRange && this.doc.selection && this.doc.selection.type === "Control") {
                    range = this.doc.selection.createRange();
                    if (range && range.length) {
                        selectedNode = range.item(0);
                    }
                }

                selection = this.getSelection(this.doc);
                if (selection.focusNode === selection.anchorNode) {
                    selectedNode = selection.focusNode;
                } else {
                    range = this.getRange(this.doc);
                    selectedNode = range ? range.commonAncestorContainer : this.editor.composer.sandbox.getContainer();
                }
                if (excludeEditorContainer && wysihtml5.util.isEditorNode(selectedNode)) {
                    selectedNode = null;
                }
                return selectedNode;
            },

            executeAndRestore : function (method, restoreScrollPosition) {
                var body = this.doc.body,
                    oldScrollTop = restoreScrollPosition && body.scrollTop,
                    oldScrollLeft = restoreScrollPosition && body.scrollLeft,
                    className = "_wysihtml5-temp-placeholder",
                    placeholderHtml = '<span class="' + className + '">' + wysihtml5.INVISIBLE_SPACE + '</span>',
                    range = this.getRange(this.doc),
                    caretPlaceholder,
                    newCaretPlaceholder,
                    nextSibling,
                    node,
                    newRange;

                // Nothing selected, execute and say goodbye
                if (!range) {
                    method(body, body);
                    return;
                }

                if (wysihtml5.browser.hasInsertNodeIssue()) {
                    this.doc.execCommand("insertHTML", false, placeholderHtml);
                } else {
                    node = range.createContextualFragment(placeholderHtml);
                    range.insertNode(node);
                }

                // Make sure that a potential error doesn't cause our placeholder element to be left as a placeholder
                try {
                    method(range.startContainer, range.endContainer);
                } catch (e) {
                    setTimeout(function () {
                        throw e;
                    }, 0);
                }

                caretPlaceholder = this.doc.querySelector("." + className);
                if (caretPlaceholder) {
                    newRange = rangy.createRange(this.doc);
                    nextSibling = caretPlaceholder.nextSibling;
                    // Opera is so fucked up when you wanna set focus before a <br>
                    if (wysihtml5.browser.hasInsertNodeIssue() && nextSibling && nextSibling.nodeName === "BR") {
                        newCaretPlaceholder = this.doc.createTextNode(wysihtml5.INVISIBLE_SPACE);
                        dom.insert(newCaretPlaceholder).after(caretPlaceholder);
                        newRange.setStartBefore(newCaretPlaceholder);
                        newRange.setEndBefore(newCaretPlaceholder);
                    } else {
                        newRange.selectNode(caretPlaceholder);
                        newRange.deleteContents();
                    }
                    this.setSelection(newRange);
                } else {
                    // fallback for when all hell breaks loose
                    body.focus();
                }

                if (restoreScrollPosition) {
                    body.scrollTop = oldScrollTop;
                    body.scrollLeft = oldScrollLeft;
                }

                // Remove it again, just to make sure that the placeholder is definitely out of the dom tree
                try {
                    caretPlaceholder.parentNode.removeChild(caretPlaceholder);
                } catch (e2) {
                }
            },

            /**
             * Different approach of preserving the selection (doesn't modify the dom)
             * Takes all text nodes in the selection and saves the selection position in the first and last one
             */
            executeAndRestoreSimple : function (method) {
                var range = this.getRange(),
                    body = this.doc.body,
                    newRange,
                    firstNode,
                    lastNode,
                    textNodes,
                    rangeBackup;

                // Nothing selected, execute and say goodbye
                if (!range) {
                    method(body, body);
                    return;
                }

                textNodes = range.getNodes([3]);
                firstNode = textNodes[0] || range.startContainer;
                lastNode = textNodes[textNodes.length - 1] || range.endContainer;

                rangeBackup = {
                    collapsed : range.collapsed,
                    startContainer : firstNode,
                    startOffset : firstNode === range.startContainer ? range.startOffset : 0,
                    endContainer : lastNode,
                    endOffset : lastNode === range.endContainer ? range.endOffset : lastNode.length
                };

                try {
                    method(range.startContainer, range.endContainer);
                } catch (e) {
                    setTimeout(function () {
                        throw e;
                    }, 0);
                }

                newRange = rangy.createRange(this.doc);
                try {
                    newRange.setStart(rangeBackup.startContainer, rangeBackup.startOffset);
                } catch (e1) {
                }
                try {
                    newRange.setEnd(rangeBackup.endContainer, rangeBackup.endOffset);
                } catch (e2) {
                }
                try {
                    this.setSelection(newRange);
                } catch (e3) {
                }
            },

            set : function (node, offset) {
                var newRange = rangy.createRange(this.doc);
                newRange.setStart(node, offset || 0);
                this.setSelection(newRange);
            },

            /**
             * Insert html at the caret position and move the cursor after the inserted html
             *
             * @param {String} html HTML string to insert
             * @example
             *    selection.insertHTML("<p>foobar</p>");
             */
            insertHTML : function (html) {
                var range = rangy.createRange(this.doc),
                    node = range.createContextualFragment(html),
                    lastChild = node.lastChild;
                this.insertNode(node);
                if (lastChild) {
                    this.setAfter(lastChild);
                }
            },

            /**
             * Insert a node at the caret position and move the cursor behind it
             *
             * @param {Object} node HTML string to insert
             * @example
             *    selection.insertNode(document.createTextNode("foobar"));
             */
            insertNode : function (node) {
                var range = this.getRange();
                if (range) {
                    range.insertNode(node);
                }
            },

            /**
             * Wraps current selection with the given node
             *
             * @param {Object} node The node to surround the selected elements with
             */
            surround : function (node) {
                var range = this.getRange();
                if (!range) {
                    return;
                }

                try {
                    // This only works when the range boundaries are not overlapping other elements
                    range.surroundContents(node);
                    this.selectNode(node);
                } catch (e) {
                    // fallback
                    node.appendChild(range.extractContents());
                    range.insertNode(node);
                }
            },

            /**
             * Scroll the current caret position into the view
             * FIXME: This is a bit hacky, there might be a smarter way of doing this
             *
             * @example
             *    selection.scrollIntoView();
             */
            scrollIntoView : function () {
                var selectedNodes = this.composer.selection.getNodes(3);
                if (selectedNodes && selectedNodes.length > 0) {
                    var firstNode = selectedNodes[0];
                    while (firstNode.nodeType === 3) {
                        firstNode = firstNode.parentElement;
                    }
                    /* Using scrollIntoViewIfNeeded for Chrome and
                     * scrollIntoView for other browsers */
                    if (typeof firstNode.scrollIntoViewIfNeeded === "function") {
                        firstNode.scrollIntoViewIfNeeded();
                    } else if (typeof firstNode.scrollIntoView === "function") {
                        firstNode.scrollIntoView();
                    }
                }
            },

            /**
             * Select line where the caret is in
             */
            selectLine : function () {
                if (wysihtml5.browser.supportsSelectionModify()) {
                    this._selectLine_W3C();
                } else if (this.doc.selection) {
                    this._selectLine_MSIE();
                }
            },

            /**
             * See https://developer.mozilla.org/en/DOM/Selection/modify
             */
            _selectLine_W3C : function () {
                var win = this.doc.defaultView,
                    selection = win.getSelection();
                selection.modify("extend", "left", "lineboundary");
                selection.modify("extend", "right", "lineboundary");
            },

            _selectLine_MSIE : function () {
                var range = this.doc.selection.createRange(),
                    rangeTop = range.boundingTop,
                    rangeHeight = range.boundingHeight,
                    scrollWidth = this.doc.body.scrollWidth,
                    rangeBottom,
                    rangeEnd,
                    measureNode,
                    i,
                    j;

                if (!range.moveToPoint) {
                    return;
                }

                if (rangeTop === 0) {
                    // Don't know why, but when the selection ends at the end of a line
                    // range.boundingTop is 0
                    measureNode = this.doc.createElement("span");
                    this.insertNode(measureNode);
                    rangeTop = measureNode.offsetTop;
                    measureNode.parentNode.removeChild(measureNode);
                }

                rangeTop += 1;

                for (i = -10;
                     i < scrollWidth;
                     i += 2) {
                    try {
                        range.moveToPoint(i, rangeTop);
                        break;
                    } catch (e1) {
                    }
                }

                // Investigate the following in order to handle multi line selections
                rangeBottom = rangeTop + (rangeHeight ? (rangeHeight - 1) : 0);
                //rangeBottom = rangeTop;
                rangeEnd = this.doc.selection.createRange();
                for (j = scrollWidth;
                     j >= 0;
                     j--) {
                    try {
                        rangeEnd.moveToPoint(j, rangeBottom);
                        break;
                    } catch (e2) {
                    }
                }

                range.setEndPoint("EndToEnd", rangeEnd);
                range.select();
            },

            getText : function () {
                var selection = this.getSelection();
                return selection ? selection.toString() : "";
            },

            getNodes : function (nodeType, filter) {
                var range = this.getRange();
                if (range) {
                    return range.getNodes([nodeType], filter);
                } else {
                    return [];
                }
            },

            getRange : function () {
                var selection = this.getSelection();
                /* Check if the focusNode is editor div element or its child
                *  For IE, on selecting text with Ctrl+A the focus node is editor node */
                return selection && selection.rangeCount && (this.composer.container === selection.focusNode || $(this.composer.container).has(selection.focusNode).length > 0) && selection.getRangeAt(0);
            },

            getSelection : function () {
                return rangy.getSelection(this.doc.defaultView || this.doc.parentWindow);
            },
            getCurrentRange : function () {
                var selection = rangy.getSelectionWithoutRefersh(this.doc.defaultView || this.doc.parentWindow);
                return selection && selection.rangeCount && selection.getRangeAt(0);
            },

            setSelection : function (range) {
                var win = this.doc.defaultView || this.doc.parentWindow,
                    selection = rangy.getSelection(win);
                return selection.setSingleRange(range);
            }
        });
})(wysihtml5);
/**
 * Inspired by the rangy CSS Applier module written by Tim Down and licensed under the MIT license.
 * http://code.google.com/p/rangy/
 *
 * changed in order to be able ...
 *    - to use custom tags
 *    - to detect and replace similar css classes via reg exp
 */
(function (wysihtml5, rangy) {
    var defaultTagName = "span";

    var REG_EXP_WHITE_SPACE = /\s+/g;

    function hasClass(el, cssClass, regExp) {
        if (!el.className) {
            return false;
        }

        var matchingClassNames = el.className.match(regExp) || [];
        return matchingClassNames[matchingClassNames.length - 1] === cssClass;
    }

    function hasAttribute(el, attributes) {
        if (el.nodeType == wysihtml5.TEXT_NODE || el.nodeType == 9) {
            return false;
        }
        var st = el.getAttribute("style");
        if (!st) {
            return false;
        }
        for (var attribute in attributes) {
            if (el.style.getPropertyValue(attribute)) {
                var currentAttributeValue = el.style.getPropertyValue(attribute).replace(/px/, "");
                currentAttributeValue = currentAttributeValue.replace(/pt/, "");
                currentAttributeValue = currentAttributeValue.replace(/["']/g, "");
                var newAttributeValue = attributes[attribute] ? attributes[attribute].replace(/px/, "") : null;
                newAttributeValue = newAttributeValue ? newAttributeValue.replace(/pt/, "") : null;
                if (newAttributeValue != null && currentAttributeValue == newAttributeValue) {
                    return true;
                } else if (!attributes[attribute]) {
                    return true;
                }
            }
        }
        return false;
    }

    function addClass(el, cssClass, regExp) {
        if (el.className) {
            removeClass(el, regExp);
            el.className += " " + cssClass;
        } else {
            el.className = cssClass;
        }
    }

    function addAttribute(el, attributes, clearPreStyle) {
        if (clearPreStyle && el) {
            el.removeAttribute("style");
        }
        if (attributes != null) {
            for (attribute in attributes) {
                if (el.style) {
                    el.style.removeProperty(attribute);
                }
                var st = el.getAttribute('style');
                if (st != null) {
                    var index = st.indexOf(attribute);
                    if (attribute == "color") {
                        /* If span had "background-color" in style and we search for "color" then it returns the index of color
                         which is present in "background-color" string. Because of this background-color which was applied earlier was lost.
                         */
                        st = st.replace("background-color", "background-customclr");
                        index = st.indexOf(attribute);
                        st = st.replace("background-customclr", "background-color");
                    }
                    if (index >= 0) {// Contains custom Style attribute try remove if already exists and execpeting custom attribute to contain value true
                        st = st.substr(0, index) + st.substr(index + attribute.length + 6); // adding +6 charcter as we execpeting custom attribute value to true or false end with ;
                    }
                    el.setAttribute('style', attribute + ":" + attributes[attribute] + ";" + st);
                } else {
                    el.setAttribute('style', attribute + ":" + attributes[attribute] + ";");
                }
            }
        }
    }

    function addDataAttribute(el, attributes, clearPreDataAttr) {
        if (el) {
            if (clearPreDataAttr && $(el).data()) {
                var data = $(el).data();
                for (var key in data) {
                    $(el).removeData(key);
                    $(el).removeAttr("data-" + key);
                }
            }
            for (var attribute in attributes) {
                $(el).data(attribute, attributes[attribute]);
                $(el).attr('data-' + attribute, attributes[attribute]);
            }
        }
    }

    function removeClass(el, regExp) {
        if (el.className) {
            el.className = el.className.replace(regExp, "");
        }
    }

    function hasSameClasses(el1, el2) {
        return el1.className.replace(REG_EXP_WHITE_SPACE, " ") == el2.className.replace(REG_EXP_WHITE_SPACE, " ");
    }

    function replaceWithOwnChildren(el) {
        var parent = el.parentNode;
        while (el.firstChild) {
            parent.insertBefore(el.firstChild, el);
        }
        parent.removeChild(el);
    }

    function elementsHaveSameNonClassAttributes(el1, el2) {
        if (el1.attributes.length != el2.attributes.length) {
            return false;
        }
        for (var i = 0, len = el1.attributes.length, attr1, attr2, name;
             i < len;
             ++i) {
            attr1 = el1.attributes[i];
            name = attr1.name;
            if (name != "class") {
                attr2 = el2.attributes.getNamedItem(name);
                if (attr1.specified != attr2.specified) {
                    return false;
                }
                if (attr1.specified && attr1.nodeValue !== attr2.nodeValue) {
                    return false;
                }
            }
        }
        return true;
    }

    function isSplitPoint(node, offset) {
        if (rangy.dom.isCharacterDataNode(node)) {
            if (offset == 0) {
                return !!node.previousSibling;
            } else if (offset == node.length) {
                return !!node.nextSibling;
            } else {
                return true;
            }
        }

        return offset > 0 && offset < node.childNodes.length;
    }

    function splitNodeAt(node, descendantNode, descendantOffset) {
        var newNode;
        if (rangy.dom.isCharacterDataNode(descendantNode)) {
            if (descendantOffset == 0) {
                descendantOffset = rangy.dom.getNodeIndex(descendantNode);
                descendantNode = descendantNode.parentNode;
            } else if (descendantOffset == descendantNode.length) {
                descendantOffset = rangy.dom.getNodeIndex(descendantNode) + 1;
                descendantNode = descendantNode.parentNode;
            } else {
                newNode = rangy.dom.splitDataNode(descendantNode, descendantOffset);
            }
        }
        if (!newNode) {
            newNode = descendantNode.cloneNode(false);
            if (newNode.id) {
                newNode.removeAttribute("id");
            }
            var child;
            while ((child = descendantNode.childNodes[descendantOffset])) {
                newNode.appendChild(child);
            }
            rangy.dom.insertAfter(newNode, descendantNode);
        }
        return (descendantNode == node) ? newNode : splitNodeAt(node, newNode.parentNode, rangy.dom.getNodeIndex(newNode));
    }

    function Merge(firstNode) {
        this.isElementMerge = (firstNode.nodeType == wysihtml5.ELEMENT_NODE);
        this.firstTextNode = this.isElementMerge ? firstNode.lastChild : firstNode;
        this.textNodes = [this.firstTextNode];
    }

    Merge.prototype = {
        doMerge : function () {
            var textBits = [], textNode, parent, text;
            for (var i = 0, len = this.textNodes.length;
                 i < len;
                 ++i) {
                textNode = this.textNodes[i];
                parent = textNode.parentNode;
                textBits[i] = textNode.data;
                if (i) {
                    parent.removeChild(textNode);
                    if (!parent.hasChildNodes()) {
                        parent.parentNode.removeChild(parent);
                    }
                }
            }
            this.firstTextNode.data = text = textBits.join("");
            return text;
        },

        getLength : function () {
            var i = this.textNodes.length, len = 0;
            while (i--) {
                len += this.textNodes[i].length;
            }
            return len;
        },

        toString : function () {
            var textBits = [];
            for (var i = 0, len = this.textNodes.length;
                 i < len;
                 ++i) {
                textBits[i] = "'" + this.textNodes[i].data + "'";
            }
            return "[Merge(" + textBits.join(",") + ")]";
        }
    };

    function HTMLApplier(tagNames, cssClass, similarClassRegExp, normalize, attributes, clearPreStyle, dataAttributes, clearPreDataAttr) {
        this.tagNames = tagNames || [defaultTagName];
        this.cssClass = cssClass || "";
        this.similarClassRegExp = similarClassRegExp;
        this.normalize = normalize;
        this.applyToAnyTagName = false;
        this.attributes = attributes;
        this.clearPreStyle = clearPreStyle;
        this.dataAttributes = dataAttributes;
        this.clearPreDataAttr = clearPreDataAttr;
    }

    HTMLApplier.prototype = {
        getAncestorWithClassAndAttribute : function (node) {
            var cssClassMatch;

            while (node) {
                cssClassMatch = this.cssClass ? hasClass(node, this.cssClass, this.similarClassRegExp) : true;
                var textNode = node;
                if ((textNode.nodeType == wysihtml5.ELEMENT_NODE) && this.attributes) {
                    var attributes = this.attributes;
                    var attributeMatch = true;
                    for (var attribute in attributes) {
                        var attributeValue = textNode.style[attribute];
                        if (attributeValue != attributes[attribute]) {
                            attributeMatch = false;
                            break;
                        }
                    }
                }
                attributeMatch = this.attributes ? attributeMatch : true;

                if (node.nodeType == wysihtml5.ELEMENT_NODE && rangy.dom.arrayContains(this.tagNames, node.tagName.toLowerCase()) && cssClassMatch && attributeMatch) {
                    return node;
                }
                node = node.parentNode;
            }
            return false;
        },
        getAncestor : function (node) {
            if (this.attributes || this.dataAttributes) {
                return this.getAncestorWithAttributes(node);
            } else {
                return this.getAncestorWithClass(node);
            }
        },
        getAncestorWithAttributes : function (node) {
            var attributesMatch;
            if (!this.attributes) {
                return false;
            }
            while (node) {
                attributesMatch = this.attributes ? hasAttribute(node, this.attributes) : true;
                if (node.nodeType == wysihtml5.ELEMENT_NODE && (rangy.dom.arrayContains(this.tagNames, node.tagName.toLowerCase()) || wysihtml5.util.isEditorNode(node)) && attributesMatch) {
                    return node;
                }
                if (node && node.style && this.attributes) {
                    var attrExists = node.style.getPropertyValue((Object.keys(this.attributes))[0]);
                    if (attrExists) {
                        return false;
                    }
                }
                node = node.parentNode;
            }
            return false;
        },
        getAncestorWithClass : function (node) {
            var cssClassMatch;

            while (node) {
                cssClassMatch = this.cssClass ? hasClass(node, this.cssClass, this.similarClassRegExp) : true;
                if (node.nodeType == wysihtml5.ELEMENT_NODE && rangy.dom.arrayContains(this.tagNames, node.tagName.toLowerCase()) && cssClassMatch) {
                    return node;
                }
                node = node.parentNode;
            }
            return false;
        },

        // Normalizes nodes after applying a CSS class to a Range.
        postApply : function (textNodes, range, textNodeNames) {
            var firstNode = textNodes[0], lastNode = textNodes[textNodes.length - 1];

            var merges = [], currentMerge;

            var rangeStartNode = firstNode, rangeEndNode = lastNode;
            var rangeStartOffset = 0, rangeEndOffset = lastNode.length;

            var textNode, precedingTextNode;

            for (var i = 0, len = textNodes.length;
                 i < len;
                 ++i) {
                textNode = textNodes[i];
                precedingTextNode = this.getAdjacentMergeableTextNode(textNode.parentNode, false, textNodeNames);
                if (precedingTextNode) {
                    if (!currentMerge) {
                        currentMerge = new Merge(precedingTextNode);
                        merges.push(currentMerge);
                    }
                    currentMerge.textNodes.push(textNode);
                    if (textNode === firstNode) {
                        rangeStartNode = currentMerge.firstTextNode;
                        rangeStartOffset = rangeStartNode.length;
                    }
                    if (textNode === lastNode) {
                        rangeEndNode = currentMerge.firstTextNode;
                        rangeEndOffset = currentMerge.getLength();
                    }
                } else {
                    currentMerge = null;
                }
            }

            // Test whether the first node after the range needs merging
            var nextTextNode = this.getAdjacentMergeableTextNode(lastNode.parentNode, true);
            if (nextTextNode) {
                if (!currentMerge) {
                    currentMerge = new Merge(lastNode);
                    merges.push(currentMerge);
                }
                currentMerge.textNodes.push(nextTextNode);
            }

            // Do the merges
            if (merges.length) {
                for (i = 0, len = merges.length;
                     i < len;
                     ++i) {
                    merges[i].doMerge();
                }
                // Set the range boundaries
                range.setStart(rangeStartNode, rangeStartOffset);
                range.setEnd(rangeEndNode, rangeEndOffset);
            }
        },

        getAdjacentMergeableTextNode : function (node, forward, textNodeNames) {
            var isTextNode = (node.nodeType == wysihtml5.TEXT_NODE);
            var el = isTextNode ? node.parentNode : node;
            var adjacentNode;
            var propName = forward ? "nextSibling" : "previousSibling";
            if (isTextNode) {
                // Can merge if the node's previous/next sibling is a text node
                adjacentNode = node[propName];
                if (adjacentNode && adjacentNode.nodeType == wysihtml5.TEXT_NODE) {
                    return adjacentNode;
                }
            } else {
                // Compare element with its sibling
                adjacentNode = el[propName];
                if (adjacentNode && this.areElementsMergeable(node, adjacentNode)) {
                    var node = adjacentNode[forward ? "firstChild" : "lastChild"];
                    if (!textNodeNames || textNodeNames.indexOf(node.nodeName) < 0) {
                        return node;
                    }
                }
            }
            return null;
        },

        areElementsMergeable : function (el1, el2) {
            return rangy.dom.arrayContains(this.tagNames, (el1.tagName || "").toLowerCase()) && rangy.dom.arrayContains(this.tagNames, (el2.tagName || "").toLowerCase()) && hasSameClasses(el1, el2) && elementsHaveSameNonClassAttributes(el1, el2);
        },

        createContainer : function (doc) {
            var el = doc.createElement(this.tagNames[0]);
            var attributes = this.attributes;
            var dataAttributes = this.dataAttributes;
            if (this.cssClass) {
                el.className = this.cssClass;
            }

            for (var attribute in attributes) {
                el.style.removeProperty(attribute);
                var st = el.getAttribute('style');
                if (st != null) {
                    el.setAttribute('style', attribute + ":" + attributes[attribute] + ";" + st);
                } else {
                    el.setAttribute('style', attribute + ":" + attributes[attribute] + ";");
                }
            }
            for (attribute in dataAttributes) {
                $(el).data(attribute, dataAttributes[attribute]);
                $(el).attr('data-' + attribute, dataAttributes[attribute]);
            }
            return el;
        },

        applyToTextNode : function (textNode) {
            var parent = textNode.parentNode;
            if (parent.childNodes.length == 1 && rangy.dom.arrayContains(this.tagNames, parent.tagName.toLowerCase())) {
                if (this.cssClass) {
                    addClass(parent, this.cssClass, this.similarClassRegExp);
                }
                addAttribute(parent, this.attributes, this.clearPreStyle);
                addDataAttribute(parent, this.dataAttributes, this.clearPreDataAttr);
            } else {
                var el = this.createContainer(rangy.dom.getDocument(textNode));
                textNode.parentNode.insertBefore(el, textNode);
                el.appendChild(textNode);
            }
        },

        isRemovable : function (el) {
            return rangy.dom.arrayContains(this.tagNames, el.tagName.toLowerCase()) && wysihtml5.lang.string(el.className).trim() == this.cssClass;
        },

        undoToTextNode : function (textNode, range, ancestorWithClass) {
            if (!range.containsNode(ancestorWithClass)) {
                // Split out the portion of the ancestor from which we can remove the CSS class
                var ancestorRange = range.cloneRange();
                ancestorRange.selectNode(ancestorWithClass);

                if (ancestorRange.isPointInRange(range.endContainer, range.endOffset) && isSplitPoint(range.endContainer, range.endOffset)) {
                    splitNodeAt(ancestorWithClass, range.endContainer, range.endOffset);
                    range.setEndAfter(ancestorWithClass);
                }
                if (ancestorRange.isPointInRange(range.startContainer, range.startOffset) && isSplitPoint(range.startContainer, range.startOffset)) {
                    ancestorWithClass = splitNodeAt(ancestorWithClass, range.startContainer, range.startOffset);
                }
            }

            if (this.similarClassRegExp) {
                removeClass(ancestorWithClass, this.similarClassRegExp);
                for (var attribute in this.attributes) {
                    ancestorWithClass.style.removeProperty(attribute);
                }
            }
            if (this.isRemovable(ancestorWithClass)) {
                replaceWithOwnChildren(ancestorWithClass);
            }
        },

        applyToRange : function (range, composer) {
            var applied = this.handleListSelection(range, composer);
            var textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            if (!textNodes.length) {
                try {
                    var node = this.createContainer(range.endContainer.ownerDocument);
                    range.surroundContents(node);
                    this.selectNode(range, node);
                    return;
                } catch (e) {
                }
            }

            range.splitBoundaries();
            textNodes = range.getNodes([wysihtml5.TEXT_NODE]);

            if (textNodes.length) {
                var textNodeNames = [];
                if (composer.config.parserRules && composer.config.parserRules.textNodes) {
                    textNodeNames = composer.config.parserRules.textNodes;
                }
                var textNode;

                for (var i = 0, len = textNodes.length;
                     i < len;
                     ++i) {
                    textNode = textNodes[i];
                    var parentEl = wysihtml5.dom.getParentElement(textNode, {nodeName : textNodeNames});
                    if (parentEl) {
                        textNode = parentEl;
                    }
                    if (!this.getAncestor(textNode)) {
                        this.applyToTextNode(textNode);
                    }
                }
                range.setStart(textNodes[0], 0);
                textNode = textNodes[textNodes.length - 1];
                range.setEnd(textNode, textNode.length);

                if (this.normalize) {
                    this.postApply(textNodes, range, textNodeNames);
                }
            }
        },

        handleListSelection : function (range, composer) {
            nodeList = composer.selection.getNodes(3);
            var handledListSelection = false;
            if (nodeList.length > 0) {
                for (i = 0;
                     i < nodeList.length;
                     i++) {
                    node = nodeList[i];
                    node = node.parentNode;
                    if ((node.nodeName == "LI") && (composer.selection.getText().trim() == node.textContent)) {
                        if (node.childNodes.length == 1 && rangy.dom.arrayContains(this.tagNames, node.tagName.toLowerCase())) {
                            if (this.cssClass) {
                                addClass(node, this.cssClass, this.similarClassRegExp);
                            }
                            addAttribute(node, this.attributes, this.clearPreStyle);
                            addDataAttribute(parent, this.dataAttributes, this.clearPreDataAttr);
                        }
                        return true;
                    } else if (!wysihtml5.util.isEditorNode(node)) {
                        while (!(node.nodeName == "LI") && !wysihtml5.util.isEditorNode(node)) {
                            node = node.parentElement;
                        }
                        if ((node.textContent && composer.selection.getText().trim().indexOf(node.textContent.trim()) > -1) && !wysihtml5.util.isEditorNode(node)) {
                            if (this.cssClass) {
                                addClass(node, this.cssClass, this.similarClassRegExp);
                            }
                            addAttribute(node, this.attributes, this.clearPreStyle);
                            addDataAttribute(parent, this.dataAttributes, this.clearPreDataAttr);
                            handledListSelection = true;
                        }
                    }
                }
            } else {
                var selectedNode = composer.selection.getSelectedNode();
                if (selectedNode && selectedNode != undefined) {
                    while (!(selectedNode.nodeName == "LI") && !wysihtml5.util.isEditorNode(selectedNode) && selectedNode.nodeName != "#text") {
                        selectedNode = selectedNode.parentElement;
                    }
                    //CQ-4225614
                    if (composer.selection.getText().trim().indexOf(selectedNode.textContent) > -1 && !wysihtml5.util.isEditorNode(selectedNode)) {
                        if (this.cssClass) {
                            addClass(selectedNode, this.cssClass, this.similarClassRegExp);
                        }
                        addAttribute(selectedNode, this.attributes, this.clearPreStyle);
                        addDataAttribute(parent, this.dataAttributes, this.clearPreDataAttr);
                        handledListSelection = true;
                    }
                }
            }
            return handledListSelection;
        },

        undoToRange : function (range, composer) {
            var textNodes = range.getNodes([wysihtml5.TEXT_NODE]), textNode, ancestorWithClass;
            if (textNodes.length) {
                range.splitBoundaries();
                textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            } else {
                var doc = range.endContainer.ownerDocument,
                    node = doc.createTextNode(wysihtml5.INVISIBLE_SPACE);
                range.insertNode(node);
                range.selectNode(node);
                textNodes = [node];
            }

            for (var i = 0, len = textNodes.length;
                 i < len;
                 ++i) {
                textNode = textNodes[i];
                ancestorWithClass = this.getAncestor(textNode);
                if (ancestorWithClass) {
                    this.undoToTextNode(textNode, range, ancestorWithClass);
                }
            }

            if (len == 1) {
                this.selectNode(range, textNodes[0]);
            } else {
                range.setStart(textNodes[0], 0);
                textNode = textNodes[textNodes.length - 1];
                range.setEnd(textNode, textNode.length);

                if (this.normalize) {
                    this.postApply(textNodes, range);
                }
            }
        },

        selectNode : function (range, node) {
            var isElement = node.nodeType === wysihtml5.ELEMENT_NODE,
                canHaveHTML = "canHaveHTML" in node ? node.canHaveHTML : true,
                content = isElement ? node.innerHTML : node.data,
                isEmpty = (content === "" || content === wysihtml5.INVISIBLE_SPACE);

            if (isEmpty && isElement && canHaveHTML) {
                // Make sure that caret is visible in node by inserting a zero width no breaking space
                try {
                    node.innerHTML = wysihtml5.INVISIBLE_SPACE;
                } catch (e) {
                }
            }
            range.selectNodeContents(node);
            if (isEmpty && isElement) {
                range.collapse(false);
            } else if (isEmpty) {
                range.setStartAfter(node);
                range.setEndAfter(node);
            }
        },

        getTextSelectedByRange : function (textNode, range) {
            var textRange = range.cloneRange();
            textRange.selectNodeContents(textNode);

            var intersectionRange = textRange.intersection(range);
            var text = intersectionRange ? intersectionRange.toString() : "";
            textRange.detach();

            return text;
        },

        isAppliedToRangeByClassAndAttribute : function (range) {

            var textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            var attributes = this.attributes;
            var attributeValue = new Array();
            if (textNodes.length) {
                var textNode;
                for (var i = 0, len = textNodes.length;
                     i < len;
                     i++) {
                    textNode = textNodes[i];
                    while (!wysihtml5.util.isEditorNode(textNode)) {
                        var textNode = textNode.parentNode;
                        var j = 0;
                        for (var attribute in attributes) {
                            if (!attributeValue[j]) {
                                if (textNode.style.getPropertyValue(attribute) == attributes[attribute]) {
                                    attributeValue[j++] = "true";
                                }
                            }
                        }
                        if (this.dataAttributes) {
                            for (attribute in this.dataAttributes) {
                                if (!attributeValue[j]) {
                                    if ($(textNode).data(attribute) == this.dataAttributes[attribute]) {
                                        attributeValue[j++] = "true";
                                    }
                                }
                            }
                        }
                    }
                }
            }
            var i = 0;
            for (attribute in attributes) {
                if (!attributeValue[i++]) {
                    return false;
                }
            }
            var ancestors = [],
                ancestor,
                textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            if (!textNodes.length) {
                ancestor = this.getAncestorWithAttributes(range.startContainer);
                return ancestor ? [ancestor] : false;
            }

            for (var i = 0, len = textNodes.length, selectedText;
                 i < len;
                 ++i) {
                selectedText = this.getTextSelectedByRange(textNodes[i], range);
                ancestor = this.getAncestorWithAttributes(textNodes[i]);
                if (selectedText != "" && !ancestor) {
                    return false;
                } else {
                    ancestors.push(ancestor);
                }
            }
            return ancestors;
        },

        isAppliedToRange : function (range) {

            var ancestors = [],
                ancestor,
                textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            if (!textNodes.length) {
                ancestor = this.getAncestor(range.startContainer);
                return ancestor ? [ancestor] : false;
            }

            for (var i = 0, len = textNodes.length, selectedText;
                 i < len;
                 ++i) {
                selectedText = this.getTextSelectedByRange(textNodes[i], range);
                ancestor = this.getAncestor(textNodes[i]);
                if (selectedText != "" && !ancestor) {
                    return false;
                } else {
                    ancestors.push(ancestor);
                }
            }
            return ancestors;
        },

        toggleRange : function (range, composer) {
            var isApply = false;
            if (this.attributes || this.dataAttributes) {
                isApply = this.isAppliedToRangeByClassAndAttribute(range);
            } else {
                isApply = this.isAppliedToRange(range);
            }

            if (isApply) {
                this.undoToRange(range, composer);
            } else {
                this.applyToRange(range, composer);
            }
        }
    };

    wysihtml5.selection.HTMLApplier = HTMLApplier;
})(wysihtml5, rangy);
/**
 * Rich Text Query/Formatting Commands
 *
 * @example
 *    var commands = new wysihtml5.Commands(editor);
 */
wysihtml5.Commands = Base.extend(
    /** @scope wysihtml5.Commands.prototype */ {
        constructor : function (editor) {
            this.editor = editor;
            this.composer = editor.composer;
            this.doc = this.composer.doc;
        },

        /**
         * Check whether the browser supports the given command
         *
         * @param {String} command The command string which to check (eg. "bold", "italic", "insertUnorderedList")
         * @example
         *    commands.supports("createLink");
         */
        support : function (command) {
            return wysihtml5.browser.supportsCommand(this.doc, command);
        },

        /**
         * Check whether the browser supports the given command
         *
         * @param {String} command The command string which to execute (eg. "bold", "italic", "insertUnorderedList")
         * @param {String} [value] The command value parameter, needed for some commands ("createLink", "insertImage", ...), optional for commands that don't require one ("bold", "underline", ...)
         * @example
         *    commands.exec("insertImage", "http://a1.twimg.com/profile_images/113868655/schrei_twitter_reasonably_small.jpg");
         */
        exec : function (command, value, allowUndo) {
            var obj = wysihtml5.commands[command],
                args = wysihtml5.lang.array(arguments).get(),
                method = obj && obj.exec,
                focus = obj && obj.focus,
                result = null;

            if (allowUndo == undefined) {
                allowUndo = true;
            }
            if (focus == undefined) {
                focus = true;
            }

            if (allowUndo) {
                this.editor.fire("beforecommand:composer");
            }

            if (method) {
                args.unshift(this.composer);
                // Make sure that composer is focussed (false => don't move caret to the end)
                var range = this.composer.selection.getRange();
                if (focus) {
                    this.editor.focus(false);
                }
                if (focus && this.editor.savedSelection && !range) {// Fixing LC-3911994
                    this.composer.selection.setSelection(this.editor.savedSelection);
                }
                result = method.apply(obj, args);
            } else {
                try {
                    // try/catch for buggy firefox
                    result = this.doc.execCommand(command, false, value);
                } catch (e) {
                }
            }

            this.editor.fire("aftercommand:composer");
            return result;
        },

        /**
         * Check whether the current command is active
         * If the caret is within a bold text, then calling this with command "bold" should return true
         *
         * @param {String} command The command string which to check (eg. "bold", "italic", "insertUnorderedList")
         * @param {String} [commandValue] The command value parameter (eg. for "insertImage" the image src)
         * @return {Boolean} Whether the command is active
         * @example
         *    var isCurrentSelectionBold = commands.state("bold");
         */
        state : function (command, commandValue) {
            var obj = wysihtml5.commands[command],
                args = wysihtml5.lang.array(arguments).get(),
                method = obj && obj.state;
            return this.callStateFunction(method, obj, args, command);
        },

        callbackState : function (command, commandValue, isDefault) {
            var obj = wysihtml5.commands[command],
                args = wysihtml5.lang.array(arguments).get(), method;
            if (obj && obj.callbackState) {
                method = obj && obj.callbackState;
                return this.callStateFunction(method, obj, args, command);
            } else {
                return this.state(command, commandValue, isDefault);
            }
        },

        callStateFunction : function (method, obj, args, command) {
            if (method) {
                args.unshift(this.composer);
                return method.apply(obj, args);
            } else {
                try {
                    // try/catch for buggy firefox
                    return this.doc.queryCommandState(command);
                } catch (e) {
                    return false;
                }
            }
        }
    });
wysihtml5.commands.bold = {
    exec : function (composer, command) {
        return wysihtml5.commands.formatInline.exec(composer, command, "b");
    },

    state : function (composer, command) {
        // element.ownerDocument.queryCommandState("bold") results:
        // firefox: only <b>
        // chrome:  <b>, <strong>, <h1>, <h2>, ...
        // ie:      <b>, <strong>
        // opera:   <b>, <strong>
        return wysihtml5.commands.formatInline.state(composer, command, "b");
    }
};

wysihtml5.commands.superScript = {
    exec : function (composer, command) {
        var doc = composer.doc,
            selectedNode = composer.selection.getSelectedNode(),
            subscript = selectedNode.parentNode.nodeName;
        if (composer.commands.support(command)) {
            composer.doc.execCommand(command, false, null);
        } else {
            if (subscript && subscript == "SUB") {
                var el = composer.selection.executeAndRestore(function () {
                    wysihtml5.dom.renameElement(selectedNode.parentNode, "sup");
                });
            } else {
                wysihtml5.commands.formatInline.exec(composer, command, "sup");
            }
        }
    },

    state : function (composer, command) {
        return wysihtml5.commands.formatInline.state(composer, command, "sup");
    }
};

wysihtml5.commands.subScript = {
    exec : function (composer, command) {
        var doc = composer.doc,
            selectedNode = composer.selection.getSelectedNode(),
            superscript = selectedNode.parentNode.nodeName;
        if (composer.commands.support(command)) {
            composer.doc.execCommand(command, false, null);
        } else {
            if (superscript && superscript == "SUP") {
                var el = composer.selection.executeAndRestore(function () {
                    wysihtml5.dom.renameElement(selectedNode.parentNode, "sub");
                });
            } else {
                wysihtml5.commands.formatInline.exec(composer, command, "sub");
            }
        }
    },

    state : function (composer, command) {
        return wysihtml5.commands.formatInline.state(composer, command, "sub");
    }
};

(function (wysihtml5) {
    var undef,
        NODE_NAME = "A",
        dom = wysihtml5.dom;

    function _removeFormat(composer, anchors) {
        var length = anchors.length,
            i = 0,
            anchor,
            codeElement,
            textContent;
        for (;
            i < length;
            i++) {
            anchor = anchors[i];
            codeElement = dom.getParentElement(anchor, {nodeName : "code"});
            textContent = dom.getTextContent(anchor);

            // if <a> contains url-like text content, rename it to <code> to prevent re-autolinking
            // else replace <a> with its childNodes
            if (textContent.match(dom.autoLink.URL_REG_EXP) && !codeElement) {
                // <code> element is used to prevent later auto-linking of the content
                codeElement = dom.renameElement(anchor, "code");
            } else {
                dom.replaceWithChildNodes(anchor);
            }
        }
    }

    function _format(composer, attributes) {
        var doc = composer.doc,
            tempClass = "_wysihtml5-temp-" + (+new Date()),
            tempClassRegExp = /non-matching-class/g,
            i = 0,
            length,
            anchors,
            anchor,
            hasElementChild,
            isEmpty,
            elementToSetCaretAfter,
            textContent,
            whiteSpace,
            j;
        wysihtml5.commands.formatInline.exec(composer, undef, NODE_NAME, tempClass, tempClassRegExp);

        var newText = null;
        if (attributes && attributes.alt) {
            newText = attributes.alt;
            delete attributes.alt;
        }

        anchors = doc.querySelectorAll(NODE_NAME + "." + tempClass);
        length = anchors.length;
        for (;
            i < length;
            i++) {
            anchor = anchors[i];
            anchor.removeAttribute("class");
            for (j in attributes) {
                anchor.setAttribute(j, attributes[j]);
            }
            if (newText) {
                anchor.text = newText;
            }
        }

        elementToSetCaretAfter = anchor;
        if (length === 1) {
            textContent = dom.getTextContent(anchor);
            hasElementChild = !!anchor.querySelector("*");
            isEmpty = textContent === "" || textContent === wysihtml5.INVISIBLE_SPACE;
            if (!hasElementChild && isEmpty) {
                dom.setTextContent(anchor, attributes.text || anchor.href);
                whiteSpace = doc.createTextNode(" ");
                composer.selection.setAfter(anchor);
                dom.insert(whiteSpace).after(anchor);
                elementToSetCaretAfter = whiteSpace;
            }
        }
        composer.selection.setAfter(elementToSetCaretAfter);
    }

    wysihtml5.commands.createLink = {
        /**
         * TODO: Use HTMLApplier or formatInline here
         *
         * Turns selection into a link
         * If selection is already a link, it removes the link and wraps it with a <code> element
         * The <code> element is needed to avoid auto linking
         *
         * @example
         *    // either ...
         *    wysihtml5.commands.createLink.exec(composer, "createLink", "http://www.google.de");
         *    // ... or ...
         *    wysihtml5.commands.createLink.exec(composer, "createLink", { href: "http://www.google.de", target: "_blank" });
         */
        exec : function (composer, command, value, alt, target) {
            var anchors = this.state(composer, command);
            // if (anchors) {
            // Selection contains links
            //   composer.selection.executeAndRestore(function() {
            //     _removeFormat(composer, anchors);
            //   });
            // }
            if (typeof value === "object") {
                alt = value.alt;
                target = value.target ? "_target" : "";
                value = value.url;
            }
            for (i = 0;
                 (anchors && (i < anchors.length));
                 i++) {
                var anchor = anchors[i];
                anchor.href = value;
                anchor.title = "Link: " + value;
                anchor.alt = alt;
                anchor.target = target;
            }
            if (!anchors) {
                // Create links
                value = typeof(value) === "object" ? value : {href : value, alt : alt, target : target};
                _format(composer, value);
            }
        },

        state : function (composer, command) {
            return wysihtml5.commands.formatInline.state(composer, command, "A");
        }
    };
})(wysihtml5);
/**
 * document.execCommand("fontSize") will create either inline styles (firefox, chrome) or use font tags
 * which we don't want
 * Instead we set a css class
 */
(function (wysihtml5) {
    var undef,
        REG_EXP = /font-size/g;

    wysihtml5.commands.fontSize = {
        exec : function (composer, command, size) {
            size = size + "pt";
            var attributes = {"font-size" : size};
            wysihtml5.commands.formatInline.exec(composer, command, "span", "font-size", REG_EXP, attributes);
            var domElem = wysihtml5.commands.formatBlock.state(composer, 'lineHeight', attributes);
            var leading;
            if (domElem && domElem.getAttribute) {
                leading = (domElem).getAttribute("leading");
            }
            wysihtml5.util.changeLineHeight(leading, false, 'P', composer);
        },

        state : function (composer, command, size) {
            if (size) {
                size = size + "pt";
            }
            var attributes = {"font-size" : size};
            return wysihtml5.commands.formatInline.state(composer, command, "span", "font-size", REG_EXP, attributes);
        },
        callbackState : function (composer, command, size) {
            var domElem = this.state(composer, command);
            var value = [];
            // domElement i.e Selected text nodes exist
            if (domElem && domElem.length) {
                for (var i = 0; i < domElem.length; i++) {
                    // getting different font sizes applied to selected texts
                    var fontSize =  wysihtml5.helperFn.getPropertyValue(domElem[i], "font-size");
                    // font size is not already retrieved from selected texts, add font size
                    if (!value.includes(fontSize)) {
                        value.push(fontSize);
                    }
                }
            }
            return value;
        },
        value : function () {
            return undef;
        }
    };
})(wysihtml5);
/**
 * document.execCommand("    ") will create either inline styles (firefox, chrome) or use font tags
 * which we don't want
 * Instead we set a css class
 */
(function (wysihtml5) {
    var REG_EXP = /wysiwyg-color-[0-9a-z]+/g;

    wysihtml5.commands.foreColor = {
        exec : function (composer, command, color) {
            var attributes = {"color" : color};

            return wysihtml5.commands.formatInline.exec(composer, command, "span", "wysiwyg-color-" + color, REG_EXP, attributes);
        },

        state : function (composer, command, color) {
            var attributes = {"color" : color};
            return wysihtml5.commands.formatInline.state(composer, command, "span", "wysiwyg-color-" + color, REG_EXP, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        // Following elements are grouped
        // when the caret is within a H1 and the H4 is invoked, the H1 should turn into H4
        // instead of creating a H4 within a H1 which would result in semantically invalid html
        BLOCK_ELEMENTS_GROUP = ["H1", "H2", "H3", "H4", "H5", "H6", "P", "BLOCKQUOTE", "DIV"];

    /**
     * Remove similiar classes (based on classRegExp)
     * and add the desired class name
     */
    function _addClass(element, className, classRegExp) {
        if (element.className) {
            _removeClass(element, classRegExp);
            element.className += " " + className;
        } else {
            element.className = className;
        }
    }

    function _addAttribute(element) {
        var attributes = this.attributes;
        if (element) {
            if (this.clearPreStyle) {
                element.removeAttribute("style");
            }
            for (var attribute in attributes) {
                if (element.style) {
                    element.style.removeProperty(attribute);
                }
                var st = element.getAttribute('style');
                if (st != null) {
                    element.setAttribute('style', attribute + ":" + attributes[attribute] + ";" + st);
                } else {
                    element.setAttribute('style', attribute + ":" + attributes[attribute] + ";");
                }
            }
        }
    }

    function _addDataAttribute(element) {
        if (element) {
            var dataAttributes = this.dataAttributes;
            if (this.clearPreDataAttr && $(element).data()) {
                var data = $(element).data();
                for (var key in data) {
                    $(element).removeData(key);
                    $(el).removeAttr("data-" + key);
                }
            }
            for (var attribute in dataAttributes) {
                $(element).data(attribute, attributes[attribute]);
                $(element).attr('data-' + attribute, attributes[attribute]);
            }
        }
    }

    function _removeClass(element, classRegExp) {
        element.className = element.className.replace(classRegExp, "");
    }

    /**
     * Check whether given node is a text node and whether it's empty
     */
    function _isBlankTextNode(node) {
        return node.nodeType === wysihtml5.TEXT_NODE && !wysihtml5.lang.string(node.data).trim();
    }

    /**
     * Returns previous sibling node that is not a blank text node
     */
    function _getPreviousSiblingThatIsNotBlank(node) {
        var previousSibling = node.previousSibling;
        while (previousSibling && _isBlankTextNode(previousSibling)) {
            previousSibling = previousSibling.previousSibling;
        }
        return previousSibling;
    }

    /**
     * Returns next sibling node that is not a blank text node
     */
    function _getNextSiblingThatIsNotBlank(node) {
        var nextSibling = node.nextSibling;
        while (nextSibling && _isBlankTextNode(nextSibling)) {
            nextSibling = nextSibling.nextSibling;
        }
        return nextSibling;
    }

    /**
     * Adds line breaks before and after the given node if the previous and next siblings
     * aren't already causing a visual line break (block element or <br>)
     */
    function _addLineBreakBeforeAndAfter(node) {
        var doc = node.ownerDocument,
            nextSibling = _getNextSiblingThatIsNotBlank(node),
            previousSibling = _getPreviousSiblingThatIsNotBlank(node);

        if (nextSibling && !_isLineBreakOrBlockElement(nextSibling)) {
            node.parentNode.insertBefore(doc.createElement("br"), nextSibling);
        }
        if (previousSibling && !_isLineBreakOrBlockElement(previousSibling)) {
            node.parentNode.insertBefore(doc.createElement("br"), node);
        }
    }

    /**
     * Removes line breaks before and after the given node
     */
    function _removeLineBreakBeforeAndAfter(node) {
        var nextSibling = _getNextSiblingThatIsNotBlank(node),
            previousSibling = _getPreviousSiblingThatIsNotBlank(node);

        if (nextSibling && _isLineBreak(nextSibling)) {
            nextSibling.parentNode.removeChild(nextSibling);
        }
        if (previousSibling && _isLineBreak(previousSibling)) {
            previousSibling.parentNode.removeChild(previousSibling);
        }
    }

    function _removeLastChildIfLineBreak(node) {
        var lastChild = node.lastChild;
        if (lastChild && _isLineBreak(lastChild)) {
            lastChild.parentNode.removeChild(lastChild);
        }
    }

    function _isLineBreak(node) {
        return node.nodeName === "BR";
    }

    /**
     * Checks whether the elment causes a visual line break
     * (<br> or block elements)
     */
    function _isLineBreakOrBlockElement(element) {
        if (_isLineBreak(element)) {
            return true;
        }

        if (dom.getStyle("display").from(element) === "block") {
            return true;
        }

        return false;
    }

    /**
     * Execute native query command
     * and if necessary modify the inserted node's className
     */
    function _execCommand(doc, command, nodeName, className) {
        if (className) {
            var eventListener = dom.observe(doc, "DOMNodeInserted", function (event) {
                var target = event.target,
                    displayStyle;
                if (target.nodeType !== wysihtml5.ELEMENT_NODE) {
                    return;
                }
                displayStyle = dom.getStyle("display").from(target);
                if (displayStyle.substr(0, 6) !== "inline") {
                    // Make sure that only block elements receive the given class
                    target.className += " " + className;
                }
            });
        }
        doc.execCommand(command, false, nodeName);
        if (eventListener) {
            eventListener.stop();
        }
    }

    function _selectLineAndWrap(composer, element) {
        composer.selection.selectLine();
        composer.selection.surround(element);
        _removeLineBreakBeforeAndAfter(element);
        _removeLastChildIfLineBreak(element);
        composer.selection.selectNode(element, wysihtml5.browser.displaysCaretInEmptyContentEditableCorrectly());
    }

    function _hasClasses(element) {
        return !!wysihtml5.lang.string(element.className).trim();
    }

    wysihtml5.commands.formatBlock = {
        exec : function (composer, command, nodeName, className, classRegExp) {
            var doc = composer.doc,
                blockElement = this.state(composer, command, nodeName, className, classRegExp),
                useLineBreaks = composer.config.useLineBreaks,
                defaultNodeName = useLineBreaks ? "DIV" : "P",
                selectedNode;

            nodeName = typeof(nodeName) === "string" ? nodeName.toUpperCase() : nodeName;

            if (blockElement) {
                composer.selection.executeAndRestoreSimple(function () {
                    if (classRegExp) {
                        _removeClass(blockElement, classRegExp);
                    }
                    var hasClasses = _hasClasses(blockElement);
                    if (!hasClasses && (useLineBreaks || nodeName === "P")) {
                        // Insert a line break afterwards and beforewards when there are siblings
                        // that are not of type line break or block element
                        _addLineBreakBeforeAndAfter(blockElement);
                        dom.replaceWithChildNodes(blockElement);
                    } else {
                        // Make sure that styling is kept by renaming the element to a <div> or <p> and copying over the class name
                        dom.renameElement(blockElement, nodeName === "P" ? "DIV" : defaultNodeName);
                    }
                });
                return;
            }

            // Find similiar block element and rename it (<h2 class="foo"></h2>  =>  <h1 class="foo"></h1>)
            if (nodeName === null || wysihtml5.lang.array(BLOCK_ELEMENTS_GROUP).contains(nodeName)) {
                selectedNode = composer.selection.getSelectedNode(undefined, true);
                blockElement = dom.getParentElement(selectedNode, {
                    nodeName : BLOCK_ELEMENTS_GROUP
                });

                if (blockElement) {
                    composer.selection.executeAndRestore(function () {
                        // Rename current block element to new block element and add class
                        if (nodeName) {
                            blockElement = dom.renameElement(blockElement, nodeName);
                        }
                        if (className) {
                            _addClass(blockElement, className, classRegExp);
                            _addAttribute(blockElement);
                            _addDataAttribute(blockElement);
                        }
                    });
                    return;
                }
            }

            if (composer.commands.support(command)) {
                _execCommand(doc, command, nodeName || defaultNodeName, className);
                return;
            }

            blockElement = doc.createElement(nodeName || defaultNodeName);
            if (className) {
                blockElement.className = className;
            }
            _selectLineAndWrap(composer, blockElement);
        },

        state : function (composer, command, nodeName, className, classRegExp, attributes) {
            nodeName = typeof(nodeName) === "string" ? nodeName.toUpperCase() : nodeName;
            var nodeList = composer.selection.getNodes(3);
            if (nodeList.length > 0) {
                for (i = 0;
                     i < nodeList.length;
                     i++) {
                    var node = nodeList[i];
                    if (node.textContent.trim() != "") {
                        var element = dom.getParentElement(node, {
                            nodeName : nodeName,
                            className : className,
                            classRegExp : classRegExp,
                            attributes : attributes
                        });
                        if (element == null) {
                            return null;
                        }
                    }
                }
                return element;
            } else {
                var selectedNode = composer.selection.getSelectedNode();
                return dom.getParentElement(selectedNode, {
                    nodeName : nodeName,
                    className : className,
                    classRegExp : classRegExp,
                    attributes : attributes
                });
            }
        }
    };

    /**
     * Removes empty tags before and after the given node
     */
    function _removeEmptyTagsBeforeAndAfter(node) {
        var nextSibling = _getNextSiblingThatIsNotBlank(node),
            previousSibling = _getPreviousSiblingThatIsNotBlank(node);

        if (nextSibling && !nextSibling.textContent) {
            nextSibling.parentNode.removeChild(nextSibling);
        }
        if (previousSibling && !previousSibling.textContent) {
            previousSibling.parentNode.removeChild(previousSibling);
        }
    }

    wysihtml5.commands.surroundContent = {
        exec : function (composer, command, element, emptyText) {
            var selectedNode = composer.selection.getSelectedNode(),
                isEmpty = !composer.selection.getText(),
                textNodeNames = [];
            if (composer.config.parserRules && composer.config.parserRules.textNodes) {
                textNodeNames = composer.config.parserRules.textNodes;
            }
            var textNode = wysihtml5.dom.getParentElement(selectedNode, {nodeName : textNodeNames});
            if (textNode) {
                textNode.parentElement.insertBefore(element, textNode);
                element.appendChild(textNode);
            } else if (!wysihtml5.util.isEditorNode(selectedNode) && selectedNode.textContent == composer.selection.getText()) {
                selectedNode.parentElement.insertBefore(element, selectedNode);
                element.appendChild(selectedNode);
            } else {
                composer.selection.surround(element);
            }
            _removeEmptyTagsBeforeAndAfter(element);
            if (isEmpty) {
                /* If the added element is empty add a placeholder text*/
                var firstChild = element;
                while (firstChild.firstChild && firstChild.firstChild.nodeType == 1 && firstChild.firstChild.nodeName != "BR") {
                    firstChild = firstChild.firstChild;
                }
                firstChild.textContent = emptyText;
            }
            var child;
            if (!element.nextSibling || !element.nextSibling.textContent) {
                /* If the element has no next sibling add an element
                 * with same style as last child of the element and &nbsp
                 * to enable cursor to enter the element */
                if (element.nextSibling && element.nextSibling.nodeType == 1) {
                    child = element.nextSibling;
                    while (child.firstChild && child.firstChild.nodeType === 1) {
                        child = child.firstChild;
                    }
                } else {
                    var lastChild = element.lastChild;
                    var supportedTags = ["P", "H1", "H2", "H3", "H4", "H5", "H6", "SPAN", "B", "U", "I", "SUP", "SUB", "A"];
                    while (lastChild.nodeType === 1 && supportedTags.indexOf(lastChild.nodeName) < 0) {
                        lastChild = lastChild.lastChild;
                    }
                    /* If last child type is not text, clone all the child nodes
                     * else append a span tag*/
                    if (lastChild.nodeType === 1) {
                        var cloneNode = lastChild.cloneNode();
                        if (element.nextSibling) {
                            element.parentElement.insertBefore(cloneNode, element.nextSibling);
                        } else {
                            element.parentElement.appendChild(cloneNode);
                        }
                        while (lastChild.lastChild && lastChild.lastChild.nodeType === 1) {
                            lastChild = lastChild.lastChild;
                            /* Skip all condition/repeat and list tags*/
                            if (supportedTags.indexOf(lastChild.nodeName) < 0) {
                                continue;
                            }
                            child = lastChild.cloneNode();
                            cloneNode.appendChild(child);
                            cloneNode = child;
                        }
                    } else {
                        child = document.createElement("span");
                        element.parentElement.appendChild(child);
                    }
                }
                if (child) {
                    child.innerHTML = "&nbsp";
                }
            }
            var range = rangy.createRange(composer.doc);
            range.selectNodeContents(element);
            composer.selection.setSelection(range);
        }
    };
})(wysihtml5);
/**
 * formatInline scenarios for tag "B" (| = caret, |foo| = selected text)
 *
 *   #1 caret in unformatted text:
 *      abcdefg|
 *   output:
 *      abcdefg<b>|</b>
 *
 *   #2 unformatted text selected:
 *      abc|deg|h
 *   output:
 *      abc<b>|deg|</b>h
 *
 *   #3 unformatted text selected across boundaries:
 *      ab|c <span>defg|h</span>
 *   output:
 *      ab<b>|c </b><span><b>defg</b>|h</span>
 *
 *   #4 formatted text entirely selected
 *      <b>|abc|</b>
 *   output:
 *      |abc|
 *
 *   #5 formatted text partially selected
 *      <b>ab|c|</b>
 *   output:
 *      <b>ab</b>|c|
 *
 *   #6 formatted text selected across boundaries
 *      <span>ab|c</span> <b>de|fgh</b>
 *   output:
 *      <span>ab|c</span> de|<b>fgh</b>
 */
(function (wysihtml5) {
    var // Treat <b> as <strong> and vice versa
        ALIAS_MAPPING = {
            "strong" : "b",
            "em" : "i",
            "b" : "strong",
            "i" : "em"
        },
        htmlApplier = {};

    function _getTagNames(tagName) {
        var alias = ALIAS_MAPPING[tagName];
        if (tagName.toLowerCase() == 'span') {
            return alias ? [tagName.toLowerCase(), alias.toLowerCase(), "li", "p"] : [tagName.toLowerCase(), "li", "p"];
        } else {
            return alias ? [tagName.toLowerCase(), alias.toLowerCase()] : [tagName.toLowerCase()];
        }
    }

    function _getApplier(tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute) {
        var identifier = "";
        if (attributes) {
            for (attribute in attributes) {
                identifier = tagName + ":" + className + ":" + attributes[attribute];
                break;
            }
        }
        if (dataAttribute) {
            for (attribute in dataAttribute) {
                identifier += tagName + ":" + className + ":" + dataAttribute[attribute];
            }
        } else if (identifier == "") {
            identifier = tagName + ":" + className;
        }
        if (!htmlApplier[identifier]) {
            htmlApplier[identifier] = new wysihtml5.selection.HTMLApplier(_getTagNames(tagName), className, classRegExp, true, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute);
        }
        return htmlApplier[identifier];
    }

    wysihtml5.commands.formatInline = {
        exec : function (composer, command, tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute) {
            var range = composer.selection.getRange();
            if (!range) {
                return false;
            }
            _getApplier(tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute).toggleRange(range, composer);
            composer.selection.setSelection(range);
        },
        state : function (composer, command, tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute) {
            var doc = composer.doc,
                aliasTagName = ALIAS_MAPPING[tagName] || tagName,
                range;

            // Check whether the document contains a node with the desired tagName
            if (!wysihtml5.dom.hasElementWithTagName(doc, tagName) && !wysihtml5.dom.hasElementWithTagName(doc, aliasTagName)) {
                return false;
            }

            // Check whether the document contains a node with the desired className
            //if (className && !wysihtml5.dom.hasElementWithClassName(doc, className)) {
            //   return false;
            //}

            range = composer.selection.getRange();
            if (!range) {
                return false;
            }
            return _getApplier(tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute).isAppliedToRange(range);
        }
    };
})(wysihtml5);
wysihtml5.commands.insertHTML = {
    exec : function (composer, command, html) {
        if (composer.commands.support(command)) {
            composer.doc.execCommand(command, false, html);
        } else {
            composer.selection.insertHTML(html);
        }
    },

    state : function () {
        return false;
    }
};
(wysihtml5);
wysihtml5.commands.insertText = {
    exec : function (composer, command, text) {
        if (composer.commands.support(command)) {
            composer.doc.execCommand(command, false, text);
        } else {
            if (composer.selection && composer.selection.getText() != "") {
                composer.doc.execCommand("delete", false, null);
            }
            // Implementing multi line insertText ( incase of paste)
            if (text) {
                var multiLines = text.split("\r\n"); // split by CR + LF
                var textNode;
                for (var index = 0;
                     index < multiLines.length;
                     index++) {
                    textNode = composer.selection.doc.createTextNode(multiLines[index]);
                    composer.selection.insertNode(textNode);
                    if (multiLines.length > 1 && index < multiLines.length - 1) {
                        composer.selection.insertNode(composer.selection.doc.createElement("br"));
                    }
                }
                composer.selection.set(textNode, textNode.length);
            }
        }
    },

    state : function () {
        return false;
    }
};
(function (wysihtml5) {
    var NODE_NAME = "IMG";

    wysihtml5.commands.insertImage = {
        /**
         * Inserts an <img>
         * If selection is already an image link, it removes it
         *
         * @example
         *    // either ...
         *    wysihtml5.commands.insertImage.exec(composer, "insertImage", "http://www.google.de/logo.jpg");
         *    // ... or ...
         *    wysihtml5.commands.insertImage.exec(composer, "insertImage", { src: "http://www.google.de/logo.jpg", title: "foo" });
         */
        exec : function (composer, command, value) {
            value = typeof(value) === "object" ? value : {src : value};

            var doc = composer.doc,
                image = this.state(composer),
                textNode,
                i,
                parent;

            if (image) {
                // Image already selected, set the caret before it and delete it
                composer.selection.setBefore(image);
                parent = image.parentNode;
                parent.removeChild(image);

                // and it's parent <a> too if it hasn't got any other relevant child nodes
                wysihtml5.dom.removeEmptyTextNodes(parent);
                if (parent.nodeName === "A" && !parent.firstChild) {
                    composer.selection.setAfter(parent);
                    parent.parentNode.removeChild(parent);
                }

                // firefox and ie sometimes don't remove the image handles, even though the image got removed
                wysihtml5.quirks.redraw(composer.element);
                return;
            }

            image = doc.createElement(NODE_NAME);

            for (i in value) {
                if (i === "className") {
                    i = "class";
                }
                image.setAttribute(i, value[i]);
            }

            composer.selection.insertNode(image);
            if (wysihtml5.browser.hasProblemsSettingCaretAfterImg()) {
                textNode = doc.createTextNode(wysihtml5.INVISIBLE_SPACE);
                composer.selection.insertNode(textNode);
                composer.selection.setAfter(textNode);
            } else {
                composer.selection.setAfter(image);
            }
        },

        state : function (composer) {
            var doc = composer.doc,
                selectedNode,
                text,
                imagesInSelection;

            if (!wysihtml5.dom.hasElementWithTagName(doc, NODE_NAME)) {
                return false;
            }

            selectedNode = composer.selection.getSelectedNode();
            if (!selectedNode) {
                return false;
            }

            if (selectedNode.nodeName === NODE_NAME) {
                // This works perfectly in IE
                return selectedNode;
            }

            if (selectedNode.nodeType !== wysihtml5.ELEMENT_NODE) {
                return false;
            }

            text = composer.selection.getText();
            text = wysihtml5.lang.string(text).trim();
            if (text) {
                return false;
            }

            imagesInSelection = composer.selection.getNodes(wysihtml5.ELEMENT_NODE, function (node) {
                return node.nodeName === "IMG";
            });

            if (imagesInSelection.length !== 1) {
                return false;
            }

            return imagesInSelection[0];
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    var LINE_BREAK = "<br>" + (wysihtml5.browser.needsSpaceAfterLineBreak() ? " " : "");

    wysihtml5.commands.insertLineBreak = {
        exec : function (composer, command) {
            if (composer.commands.support(command)) {
                composer.doc.execCommand(command, false, null);
                if (!wysihtml5.browser.autoScrollsToCaret()) {
                    composer.selection.scrollIntoView();
                }
            } else {
                composer.commands.exec("insertHTML", LINE_BREAK);
            }
        },

        state : function () {
            return false;
        }
    };
})(wysihtml5);
wysihtml5.commands.insertOrderedList = {
    exec : function (composer, command, listType) {
        var doc = composer.doc,
            selectedNode = composer.selection.getSelectedNode(undefined, true),
            list = wysihtml5.dom.getParentElement(selectedNode, {nodeName : "OL"}),
            otherList = wysihtml5.dom.getParentElement(selectedNode, {nodeName : "UL"}),
            tempClassName = "_wysihtml5-temp-" + new Date().getTime(),
            isEmpty,
            tempElement;
        var upperRomanList;
        var lowerRomanList;
        var upperAlphaList;
        var lowerAlphaList;

        //if (!list && !otherList && composer.commands.support(command)) {
        //      doc.execCommand(command, false, null);
        //      return;
        //}

        if (list && (listType == "None")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(list, composer.config.useLineBreaks);
            });
        } else if (otherList && (listType == "None")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(otherList, composer.config.useLineBreaks);
            });
        }

        if (list != null && list.getAttribute("type") == "I") {
            upperRomanList = list;
            list = null;
        }
        if (list != null && list.getAttribute("type") == "i") {
            lowerRomanList = list;
            list = null;
        }
        if (list != null && list.getAttribute("type") == "A") {
            upperAlphaList = list;
            list = null;
        }
        if (list != null && list.getAttribute("type") == "a") {
            lowerAlphaList = list;
            list = null;
        }

        if (list && (listType == "Ordered")) {
            // Unwrap list
            // <ol><li>foo</li><li>bar</li></ol>
            // becomes:
            // foo<br>bar<br>
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(list, composer.config.useLineBreaks);
            });
        } else if (upperRomanList && (listType == "I")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(upperRomanList, composer.config.useLineBreaks);
            });
        } else if (lowerRomanList && (listType == "i")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(lowerRomanList, composer.config.useLineBreaks);
            });
        } else if (upperAlphaList && (listType == "A")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(upperAlphaList, composer.config.useLineBreaks);
            });
        } else if (lowerAlphaList && (listType == "a")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(lowerAlphaList, composer.config.useLineBreaks);
            });
        } else if (otherList) {
            // Turn an unordered list into an ordered list
            // <ul><li>foo</li><li>bar</li></ul>
            // becomes:
            // <ol><li>foo</li><li>bar</li></ol>
            var el = composer.selection.executeAndRestore(function () {
                var element = wysihtml5.dom.renameElement(otherList, "ol");
                var attribute = {};
                attribute.type = listType;
                wysihtml5.dom.setAttributes(attribute).on(element);
            });
            if (el != null && listType != "Ordered") {
                el.setAttribute("type", listType);
            }
        } else if (lowerRomanList || upperRomanList || lowerAlphaList || upperAlphaList) {
            var el = wysihtml5.commands.insertOrderedList.state(composer);
            if (el != null && (listType == "Ordered")) {
                el.removeAttribute("type");
            } else {
                el.setAttribute("type", listType);
            }
        } else if (list) {
            var el = wysihtml5.commands.insertOrderedList.state(composer);
            if (el != null && (listType != "Ordered")) {
                el.setAttribute("type", listType);
            }
        } else if (listType != "None") {
            // Create list
            composer.commands.exec("formatBlock", "div", tempClassName);
            // Check if multiple element are found
            var tempElements = doc.querySelectorAll("." + tempClassName);
            if (tempElements) {
                for (var index = 0;
                     index < tempElements.length;
                     index++) {
                    tempElement = tempElements[index];
                    if (tempElement) {
                        if (index == 0) {
                            composer.selection.executeAndRestore(function () {
                                list = wysihtml5.dom.convertToList(tempElement, "ol", listType);
                            });
                        } else {
                            if (tempElement.nodeName != "LI") {
                                tempElement = wysihtml5.dom.renameElement(tempElement, "li");
                            }
                            wysihtml5.dom.removeClass(tempElement, tempClassName);
                            if (!tempElement.querySelector(wysihtml5.BLOCK_ELEMENTS_GROUP.join(","))) {
                                tempElement.innerHTML = "<p>" + tempElement.innerHTML + "</p>";
                            }
                            if (tempElement) {
                                list.appendChild(tempElement);
                            }
                        }
                        isEmpty = tempElement.innerHTML === "" || tempElement.innerHTML === wysihtml5.INVISIBLE_SPACE || tempElement.innerHTML === "<br>";
                        if (isEmpty) {
                            composer.selection.selectNode(list.querySelector("li"), true);
                        }
                    }
                }
            }
        }
    },

    state : function (composer) {
        var selectedNode = composer.selection.getSelectedNode();
        return wysihtml5.dom.getParentElement(selectedNode, {nodeName : "OL"});
    },

    callbackState : function (composer, command, value, isDefault) {
        var domElem = this.state(composer);
        if (domElem) {
            var attrVal = domElem.getAttribute('type');
            if (attrVal == null && value == 'Ordered') {//when value is 'Ordered', default ordered list numbering is used, no type attribute.
                return true;
            }
            if (attrVal == value) {
                return true;
            }
            return false;
        } else if (isDefault) {         //no domElem with "OL" would be found if we have none type
            return true;
        }
        return false;
    }
};

wysihtml5.commands.insertUnorderedList = {
    exec : function (composer, command) {
        var doc = composer.doc,
            selectedNode = composer.selection.getSelectedNode(undefined, true),
            list = wysihtml5.dom.getParentElement(selectedNode, {nodeName : "UL"}),
            otherList = wysihtml5.dom.getParentElement(selectedNode, {nodeName : "OL"}),
            tempClassName = "_wysihtml5-temp-" + new Date().getTime(),
            isEmpty,
            tempElement;

        if (!list && !otherList && composer.commands.support(command)) {
            doc.execCommand(command, false, null);
            return;
        }

        if (list) {
            // Unwrap list
            // <ul><li>foo</li><li>bar</li></ul>
            // becomes:
            // foo<br>bar<br>
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(list, composer.config.useLineBreaks);
            });
        } else if (otherList) {
            // Turn an ordered list into an unordered list
            // <ol><li>foo</li><li>bar</li></ol>
            // becomes:
            // <ul><li>foo</li><li>bar</li></ul>
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.renameElement(otherList, "ul");
            });
        } else {
            // Create list
            composer.commands.exec("formatBlock", "div", tempClassName);
            var tempElements = doc.querySelectorAll("." + tempClassName);
            if (tempElements) {
                for (var index = 0; index < tempElements.length; index++) {
                    tempElement = tempElements[index];
                    if (tempElement) {
                        if (index == 0) {
                            composer.selection.executeAndRestore(function () {
                                list = wysihtml5.dom.convertToList(tempElement, "ul");
                            });
                        } else {
                            if (tempElement.nodeName != "LI") {
                                tempElement = wysihtml5.dom.renameElement(tempElement, "li");
                            }
                            wysihtml5.dom.removeClass(tempElement, tempClassName);
                            /* Wrap within para tag if no block element present*/
                            if (!tempElement.querySelector(wysihtml5.BLOCK_ELEMENTS_GROUP.join(","))) {
                                tempElement.innerHTML = "<p>" + tempElement.innerHTML + "</p>";
                            }
                            if (tempElement) {
                                list.appendChild(tempElement);
                            }
                        }
                        isEmpty = tempElement.innerHTML === "" || tempElement.innerHTML === wysihtml5.INVISIBLE_SPACE || tempElement.innerHTML === "<br>";
                        if (isEmpty) {
                            composer.selection.selectNode(list.querySelector("li"), true);
                        }
                    }
                }
            }
        }
    },

    state : function (composer) {
        var selectedNode = composer.selection.getSelectedNode();
        return wysihtml5.dom.getParentElement(selectedNode, {nodeName : "UL"});
    },

    callbackState : function (composer) {
        var domElem = this.state(composer);
        if (domElem) {
            return true;
        }
        return false;
    }
};
wysihtml5.commands.italic = {
    exec : function (composer, command) {
        return wysihtml5.commands.formatInline.exec(composer, command, "i");
        //return wysihtml5.commands.formatInline.exec(composer, command, "i");
    },

    state : function (composer, command) {
        // element.ownerDocument.queryCommandState("italic") results:
        // firefox: only <i>
        // chrome:  <i>, <em>, <blockquote>, ...
        // ie:      <i>, <em>
        // opera:   only <i>
        return wysihtml5.commands.formatInline.state(composer, command, "i");
    }
};

(function (wysihtml5) {
    wysihtml5.commands.increaseIndent = {
        exec : function (composer, command) {
            var range = composer.selection.getRange();
            var textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            var attributeValue;
            if (textNodes.length) {
                var textNode;
                for (var i = 0, len = textNodes.length;
                     i < len;
                     ++i) {
                    textNode = textNodes[i];
                    var parent = textNode.parentNode;
                    attributeValue = parent.style["padding-left"];
                    attributeValue = attributeValue.replace(/px/, "");
                    attributeValue = attributeValue.replace(/pt/, "");
                }
            }
            if (attributeValue) {
                var value = parseInt(40) + parseInt(attributeValue);
            }
            value = value + "pt";

            var attributes = {"text-indent" : value};

            return wysihtml5.commands.formatInline.exec(composer, command, "span", "padding-left", /padding-left/g, attributes);
        },

        state : function (composer, command, value) {
            // element.ownerDocument.queryCommandState("italic") results:
            // firefox: only <i>
            // chrome:  <i>, <em>, <blockquote>, ...
            // ie:      <i>, <em>
            // opera:   only <i>
            //return wysihtml5.commands.formatInline.state(composer, command, "span","font-family-"+fontfamily,'/font-family-[0-9a-z]+/g',"font-family",fontfamily);
            value = value + "pt";
            var attributes = {"text-indent" : value};

            return wysihtml5.commands.formatInline.state(composer, command, "span", "padding-left", /padding-left/g, attributes);
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.fontFamily = {
        exec : function (composer, command, fontfamily) {

            var attributes = {"font-family" : fontfamily};

            //return wysihtml5.commands.formatInline.exec(composer, command, "p","font-family-"+fontfamily,/font-family-[0-9a-z]+/g,"font-family",fontfamily);
            return wysihtml5.commands.formatInline.exec(composer, command, "span", "font-family", /font-family/g, attributes);
        },

        state : function (composer, command, fontfamily) {
            // element.ownerDocument.queryCommandState("italic") results:
            // firefox: only <i>
            // chrome:  <i>, <em>, <blockquote>, ...
            // ie:      <i>, <em>
            // opera:   only <i>
            //return wysihtml5.commands.formatInline.state(composer, command, "span","font-family-"+fontfamily,'/font-family-[0-9a-z]+/g',"font-family",fontfamily);
            var attributes = {"font-family" : fontfamily};

            return wysihtml5.commands.formatInline.state(composer, command, "span", "font-family", /font-family/g, attributes);
        },
        callbackState : function (composer, command) {
            var domElem = this.state(composer, command, null);
            var value = [];
            // domElement i.e Selected text nodes exist
            if (domElem && domElem.length) {
                var fontFamily;
                for (var i = 0; i < domElem.length; i++) {
                    // domElement has style attribute
                    if (domElem[i].style) {
                        // getting different font families applied to selected texts
                        fontFamily = domElem[i].style.fontFamily;
                        fontFamily = fontFamily.split(",")[0];
                        fontFamily = fontFamily.replace(/\"/g, "");
                        fontFamily = fontFamily.replace(/'/g, "");
                        // font family is not already retrieved from selected texts, add font family
                        if (!value.includes(fontFamily)) {
                            value.push(fontFamily);
                        }
                    }
                }
            }
            return value;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.customStyle = {
        exec : function (composer, command, classes) {
            var attributes = {"customStyleAttribute" : true};
            var className = " textEditor-customStyle ";
            var REG_EXP = new RegExp(className + "cm-texteditor-customstyle-[a-z]+", "g");
            if (classes) {
                className += classes;
            }
            return wysihtml5.commands.formatInline.exec(composer, command, "span", className, REG_EXP, attributes);
        },

        state : function (composer, command, dataAttribute, clearPreDataAttribute, classes) {
            var attributes = {"customStyleAttribute" : true};
            var className = " textEditor-customStyle ";
            var REG_EXP = new RegExp(className + "cm-texteditor-customstyle-[a-z]+", "g");
            if (classes) {
                className += classes;
            }
            return wysihtml5.commands.formatInline.state(composer, command, "span", className, REG_EXP, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.dataAttribute = {
        exec : function (composer, command, dataAttr, clearPreDataAttribute) {
            var attributes = {"dataAttribute" : true};
            var className = "textEditor-customDataAttr";
            var REG_EXP = new RegExp(className, "g");
            return wysihtml5.commands.formatInline.exec(composer, command, "span", className, REG_EXP, attributes, null, dataAttr, clearPreDataAttribute);
        },

        state : function (composer, command, dataAttribute, clearPreDataAttribute) {
            var attributes = {"dataAttribute" : true};
            var className = "textEditor-customDataAttr";
            var REG_EXP = new RegExp(className, "g");
            return wysihtml5.commands.formatInline.state(composer, command, "span", className, REG_EXP, attributes, null, dataAttribute, clearPreDataAttribute);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.header = {
        exec : function (composer, command, headerType) {
            var className = "textEditor-header-";
            var REG_EXP = new RegExp(className + "[^\s]*", "g");
            className += headerType;
            wysihtml5.commands.formatBlock.exec(composer, command, headerType, className, REG_EXP);
            var domElem = wysihtml5.commands.formatBlock.state(composer, 'lineHeight', headerType);
            wysihtml5.util.clearFontSize(domElem);
            var leading;
            if (domElem && domElem.style && domElem.style.lineHeight) {
                composer.selection.selectNode(domElem);
                var computedStyles = window.getComputedStyle(domElem);
                var maxFontSize = 0;
                if (computedStyles) {
                    maxFontSize = computedStyles.fontSize;
                }
                if (!maxFontSize) {
                    maxFontSize = composer.config.defaultFontSize;
                }
                if (domElem.getAttribute) {
                    leading = (domElem).getAttribute("leading");
                }
                if (!leading) {
                    leading = composer.config.defaultLineHeight;
                }
                var lineHeightValue = parseInt(leading) + parseInt(maxFontSize);
                var attributes = {lineHeight : lineHeightValue, leading : leading};
                // adjusting leading and lineheight depending upon change in fontsize, this is part of fontsize transaction, we won't allow undo for this.
                domElem.style.setProperty("line-height", lineHeightValue + "pt");
                domElem.setAttribute("leading", leading);
            }
        },

        state : function (composer, command, headerType) {
            return wysihtml5.commands.formatBlock.state(composer, command, headerType);
        },
        callbackState : function (composer, command) {
            var domElem = this.state(composer, command, ["P", "H1", "H2", "H3", "H4", "H5", "H6"]);
            var value = "";
            if (domElem && domElem.nodeName) {
                value = domElem.nodeName.toLowerCase();
            }
            return value;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    if (!wysihtml5.helperFn) {
        wysihtml5.helperFn = {};
    }

    wysihtml5.helperFn.getPropertyValue = function (domElem, propertyName) {
        if (domElem && domElem.style) {
            return domElem.style.getPropertyValue(propertyName).replace('pt', '').replace('px', '');
        } else {
            return 0;
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.marginLeft = {
        exec : function (composer, command, value) {
            var marginValue = value + "pt";
            composer.applyStyle(composer, {"margin-left" : marginValue});
        },

        state : function (composer, command, marginValue) {
            if (marginValue) {
                marginValue = marginValue + "pt";
            }
            var attributes = {"margin-left" : marginValue};
            return wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], "margin-left", /margin-left/g, attributes);
        },

        callbackState : function (composer, command, marginValue) {
            var domElem = this.state(composer, command);
            return wysihtml5.helperFn.getPropertyValue(domElem, "margin-left");
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.marginRight = {
        exec : function (composer, command, value) {
            var marginValue = value + "pt";
            composer.applyStyle(composer, {"margin-right" : marginValue});
        },

        state : function (composer, command, marginValue) {
            if (marginValue) {
                marginValue = marginValue + "pt";
            }
            var attributes = {"margin-right" : marginValue};
            return wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], "margin-right", /margin-right/g, attributes);
        },

        callbackState : function (composer, command) {
            var domElem = this.state(composer, command);
            return wysihtml5.helperFn.getPropertyValue(domElem, "margin-right");
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.marginTop = {
        exec : function (composer, command, value) {
            var marginValue = value + "pt";
            composer.applyStyle(composer, {"margin-top" : marginValue});
        },

        state : function (composer, command, marginValue) {
            if (marginValue) {
                marginValue = marginValue + "pt";
            }
            var attributes = {"margin-top" : marginValue};
            return wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], "margin-top", /margin-top/g, attributes);
        },

        callbackState : function (composer, command) {
            var domElem = this.state(composer, command);
            return wysihtml5.helperFn.getPropertyValue(domElem, "margin-top");
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.marginBottom = {
        exec : function (composer, command, value) {
            var marginValue = value + "pt";
            composer.applyStyle(composer, {"margin-bottom" : marginValue});
        },

        state : function (composer, command, marginValue) {
            if (marginValue) {
                marginValue = marginValue + "pt";
            }
            var attributes = {"margin-bottom" : marginValue};
            return wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], "margin-bottom", /margin-bottom/g, attributes);
        },

        callbackState : function (composer, command, marginValue) {
            var domElem = this.state(composer, command, null);
            return wysihtml5.helperFn.getPropertyValue(domElem, "margin-bottom");
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.letterSpacing = {
        exec : function (composer, command, val) {
            val = val + "pt";
            var attributes = {"letter-spacing" : val};

            return wysihtml5.commands.formatInline.exec(composer, command, "span", "letter-spacing", /letter-spacing/g, attributes);
        },

        state : function (composer, command, val) {
            if (val) {
                val = val + "pt";
            }
            var attributes = {"letter-spacing" : val};
            return wysihtml5.commands.formatInline.state(composer, command, "span", "letter-spacing", /letter-spacing/g, attributes);
        },

        callbackState : function (composer, command) {
            var domElem = this.state(composer, command, null);
            var value = "";
            if (domElem) {
                value = wysihtml5.helperFn.getPropertyValue(domElem[0], "letter-spacing");
            }
            return value;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.lineHeight = {
        exec : function (composer, command, attributes) {
            var lineHeightValue = attributes.lineHeight;
            lineHeightValue = lineHeightValue + "pt";
            var leadingValue = attributes.leading;
            composer.applyStyle(composer, {"line-height" : lineHeightValue}, {"leading" : leadingValue});
        },
        state : function (composer, command, val) {
            if (val) {
                val = val + "pt";
            }
            var attributes = {"line-height" : val};
            return wysihtml5.commands.formatBlock.state(composer, command, "p", "line-height", /line-height/g, attributes);
        },
        callbackState : function (composer, command) {
            var domElem = this.state(composer, command, null);
            var value = "";
            if (domElem) {
                value = (domElem).getAttribute("leading");
            }
            return value;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.outdent = {
        exec : function (composer, command, alignValue) {
            if (composer.commands.support(command)) {
                composer.doc.execCommand(command, false, '0pt 5pt 0pt 0pt');
            }
        },

        state : function (composer, command, alignValue) {
            return false;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.justifyLeft = {
        exec : function (composer, command) {
            composer.applyStyle(composer, {"text-align" : "left"});
        },

        state : function (composer, command) {
            var attributes = {"text-align" : "left"};

            return wysihtml5.commands.formatBlock.state(composer, command, "p", "text-align", /text-align/g, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.justifyCenter = {
        exec : function (composer, command) {
            composer.applyStyle(composer, {"text-align" : "center"});
        },

        state : function (composer, command) {
            var attributes = {"text-align" : "center"};

            return wysihtml5.commands.formatBlock.state(composer, command, "p", "text-align", /text-align/g, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.justifyFull = {
        exec : function (composer, command) {

            composer.applyStyle(composer, {"text-align" : "justify"});
        },

        state : function (composer, command) {
            var attributes = {"text-align" : "justify"};

            return wysihtml5.commands.formatBlock.state(composer, command, "p", "text-align", /text-align/g, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.justifyRight = {
        exec : function (composer, command) {

            composer.applyStyle(composer, {"text-align" : "right"});
        },

        state : function (composer, command) {
            var attributes = {"text-align" : "right"};
            return wysihtml5.commands.formatBlock.state(composer, command, "p", "text-align", /text-align/g, attributes);
        }
    };
})(wysihtml5);

wysihtml5.util = {};
//For fixing LC-3911955
wysihtml5.util.clearFontSize = function (element) {
    if (element && element.childElementCount > 0) {
        for (var ele, index = 0;
             index < element.childElementCount;
             index++) {
            ele = element.children[index];
            if (ele && ele.style) {
                ele.style.setProperty("font-size", "");
            }
            if (ele.childElementCount > 0) {
                wysihtml5.util.clearFontSize(ele);
            }
        }
    }
};

wysihtml5.util.isEditorNode = function (node) {
    return node && node.nodeName.toLowerCase() == "div" && node.classList.contains("wysihtml5-editor");
};

wysihtml5.util.changeLineHeight = function (leading, allowUndo, nodeName, composer, forceApply) {
    if (leading == undefined) {
        leading = composer.config.defaultLineHeight;
    }
    if (allowUndo == undefined) {
        allowUndo = true;
    }
    if (nodeName == undefined) {
        nodeName = "P";
    }
    var selection = composer.selection;
    var currentSelection = selection.getRange();
    if (!currentSelection && forceApply) {// Fixing LC-3911994
        selection.setSelection(selection.editor.savedSelection);
        currentSelection = selection.getRange();
    }
    if (!currentSelection) {
        window.console.log("This error is due to changeLineHeight function.");
        return;
    }
    /* find the maxmimum fontSize in a paragraph, as lineheight is a block level attribute, need to find the maximum font-size before calculating new line height*/
    var matchingSet = {nodeName : nodeName};
    var selectedTextArr = selection.getNodes(3);
    var that = this;
    selectedTextArr.forEach(function (text) {
        var parentParagraph = wysihtml5.dom.getParentElement(text, matchingSet);
        if (!parentParagraph) {
            return;
        }
        if ((parentParagraph && parentParagraph.style && parentParagraph.style.lineHeight) || forceApply) {
            selection.selectNode(parentParagraph);
            var fontSizeSpanArr = wysihtml5.commands.fontSize.state(composer, "fontSize");
            fontSizeSpanArr = [].concat(fontSizeSpanArr);   // getCommandState sometimes can return a single span or an array, forcefully converting into an array
            var maxFontSize = 0;
            fontSizeSpanArr.forEach(function (span) {
                if (span && span.style && span.style.fontSize) {
                    var fontSize = span.style.fontSize.replace("/px/", "");
                    fontSize = fontSize.replace("/pt/", "");
                    fontSize = parseInt(fontSize);
                    maxFontSize = Math.max(fontSize, maxFontSize);
                }
            });

            if (maxFontSize == 0) {
                maxFontSize = composer.config.defaultFontSize;
            }
            var lineHeightValue = parseInt(leading) + parseInt(maxFontSize);
            var attributes = {lineHeight : lineHeightValue, leading : leading};
            // adjusting leading and lineheight depending upon change in fontsize, this is part of fontsize transaction, we won't allow undo for this.
            wysihtml5.commands.lineHeight.exec(composer, "lineHeight", attributes, allowUndo);
        }
    });
    selection.setSelection(currentSelection);
};
wysihtml5.util.getTextNodes = function (selection) {
    var textNodes = selection.getNodes(wysihtml5.TEXT_NODE);
    if (textNodes.length == 0) {
        var node = selection.getSelectedNode();
        if (node.nodeType == wysihtml5.TEXT_NODE) {
            textNodes.push(node);
        }
    }
    return textNodes;
};

wysihtml5.util.getLINodesFromTextNodes = function (textNodes) {
    var liNodes = [];
    for (var i = 0;
         i < textNodes.length;
         ++i) {
        var liParent = wysihtml5.dom.getParentElement(textNodes[i], {nodeName : "LI"});
        if (liParent) {
            liNodes.push(liParent);
        }
    }
    return liNodes;
};

wysihtml5.util.setIndent = function (node) {
    var margin = node.style.marginLeft;
    margin = margin.replace('px', '').replace('pt', '');
    var newMargin = (parseInt(margin) + 40) + 'pt';
    if (margin == "") {
        newMargin = '40pt';
    }
    node.style.marginLeft = newMargin;
};
wysihtml5.util.decreaseIndent = function (node) {
    var margin = node.style.marginLeft;
    margin = margin.replace('px', '').replace('pt', '');
    var newMargin = (parseInt(margin) - 40) + 'pt';
    node.style.marginLeft = newMargin;
};

wysihtml5.util.getImmediateChildsByTagName = function (node, tagNames) {
    var listChilds = [];
    if (node && node.children) {
        for (var i = 0;
             i < node.children.length;
             ++i) {
            if (tagNames.indexOf(node.children[i].nodeName) != -1) {
                listChilds.push(node.children[i]);
            }
        }
    }
    return listChilds;
};

wysihtml5.util.getObjectProperty = function (object, path, defaultValue) {
    var currObject = object;
    if (path) {
        var props = path.split(".");
        props.forEach(function (prop) {
            if (currObject && currObject.hasOwnProperty(prop)) {
                currObject = currObject[prop];
            } else {
                currObject = undefined;
            }
        });
    } else {
        currObject = undefined;
    }
    if (currObject) {
        return currObject;
    } else {
        return defaultValue;
    }
};

(function (wysihtml5) {
    wysihtml5.commands.outdent = {
        exec : function (composer, command, alignValue) {

            var range = composer.selection.getRange();

            // Make sure that selection contains list of only one level, don't do anything in case of multi level*/
            var startContainerParentList = wysihtml5.dom.getParentElement(range.startContainer, {nodeName : ["OL", "UL"]});
            var endContainerParentList = wysihtml5.dom.getParentElement(range.endContainer, {nodeName : ["OL", "UL"]});
            if (startContainerParentList && startContainerParentList != endContainerParentList) {
                return;
            }

            if (startContainerParentList && startContainerParentList.style && (startContainerParentList.style.marginLeft && startContainerParentList.style.marginLeft != "0px" && startContainerParentList.style.marginLeft != "0pt")) {
                wysihtml5.util.decreaseIndent(startContainerParentList);
                composer.selection.selectNode(startContainerParentList);
                return;
            } else if (!startContainerParentList) {
                var nodes = composer.selection ? composer.selection.getNodes(1) : [];
                if (!nodes || nodes.length == 0) {
                    nodes = wysihtml5.util.getTextNodes(composer.selection);
                }
                if (nodes) {
                    for (var i = 0;
                         i < nodes.length;
                         ++i) {
                        if (nodes[i] != null) {
                            var parentNode = nodes[i].parentNode;
                            if (nodes.indexOf(parentNode) < 0) {
                                var para = wysihtml5.dom.getParentElement(nodes[i], {nodeName : ["P", "OL", "UL", "DIV", "H1", "H2", "H3", "H4", "H5", "H6"]});
                                if (para && para.style && para.style.marginLeft != undefined && (para.style.marginLeft != 0 && para.style.marginLeft != "0px" && para.style.marginLeft != "0pt")) {
                                    wysihtml5.util.decreaseIndent(para);
                                }
                            }
                        }
                    }
                }
                return;
            }

            if (composer.commands.support(command)) {
                composer.doc.execCommand(command, false, '0pt 5pt 0pt 0pt');
            }

            var liNodes = wysihtml5.util.getLINodesFromTextNodes(wysihtml5.util.getTextNodes(composer.selection));

            for (var i = liNodes.length - 1;
                 i >= 0;
                 --i) {
                var parentList = wysihtml5.dom.getParentElement(liNodes[i], {nodeName : ["OL", "UL"]});
                if (parentList && liNodes[i].parentElement && liNodes[i].parentElement.nodeName == 'LI') {
                    if (liNodes[i].parentElement.nextSibling) {
                        parentList.insertBefore(liNodes[i], liNodes[i].parentElement.nextSibling);
                    } else {
                        parentList.appendChild(liNodes[i]);
                    }
                }
                composer.selection.selectNode(parentList);
            }
        },

        state : function (composer, command, alignValue) {
            return false;
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.indent = {
        exec : function (composer, command, alignValue) {

            var range = composer.selection.getRange();
            var startContainerParentList = wysihtml5.dom.getParentElement(range.startContainer, {nodeName : ["OL", "UL"]});
            if (startContainerParentList) {
                var startContainerParentListElement = wysihtml5.dom.getParentElement(range.startContainer, {nodeName : "LI"});
                /* we want to insert the new OL/UL elements after indent into the sibling before,
                 in case first element is selected too, we won't have any sibling to insert new OL/UL elements into.
                 if selection contains first element of the list,select whole list and indent*/
                if ((startContainerParentListElement && startContainerParentList.firstChild == startContainerParentListElement) || range.startContainer.nodeName == "OL") {
                    composer.selection.selectNode(startContainerParentList);
                    // apply style on this, margin-left : 40px and return
                    if (startContainerParentList.style && startContainerParentList.style.marginLeft != undefined) {
                        wysihtml5.util.setIndent(startContainerParentList);
                    }
                    return;
                }
            }

            // Make sure that selection contains list of only one level, don't do anything in case of multi level*/
            var startContainerParentList = wysihtml5.dom.getParentElement(range.startContainer, {nodeName : ["OL", "UL"]}),
                indentType;
            if (startContainerParentList) {
                indentType = startContainerParentList.getAttribute("type");
            }
            var endContainerParentList = wysihtml5.dom.getParentElement(range.endContainer, {nodeName : ["OL", "UL"]});
            if (startContainerParentList && startContainerParentList == endContainerParentList) {
                var liNodes = wysihtml5.util.getLINodesFromTextNodes(wysihtml5.util.getTextNodes(composer.selection));
                if (liNodes.length > 0) {
                    var targetListNode = liNodes[0].previousSibling;
                    if (targetListNode) {
                        var listChilds = wysihtml5.util.getImmediateChildsByTagName(targetListNode, ["OL", "UL"]);
                        for (var i = 0;
                             i < liNodes.length;
                             ++i) {
                            if (listChilds.length > 0) {
                                listChilds[0].appendChild(liNodes[i]);
                            } else {
                                var newList = document.createElement(startContainerParentList.nodeName);
                                newList.setAttribute("type", indentType);
                                newList.appendChild(liNodes[i]);        // i must be 0 here.
                                targetListNode.appendChild(newList);
                                listChilds[0] = newList;
                            }
                        }
                    } else {
                        wysihtml5.util.setIndent(startContainerParentList);
                    }
                    composer.selection.selectNode(startContainerParentList);
                }
            } else if (!startContainerParentList) {
                var nodes = composer.selection ? composer.selection.getNodes(1) : [];
                if (!nodes || nodes.length == 0) {
                    nodes = wysihtml5.util.getTextNodes(composer.selection);
                }
                if (nodes) {
                    for (var i = 0;
                         i < nodes.length;
                         ++i) {
                        if (nodes[i] != null) {
                            var parentNode = nodes[i].parentNode;
                            if (nodes.indexOf(parentNode) < 0) {
                                var para = wysihtml5.dom.getParentElement(nodes[i], {nodeName : ["P", "OL", "UL", "DIV", "H1", "H2", "H3", "H4", "H5", "H6"]});
                                if (para && para.style && para.style.marginLeft != undefined) {
                                    wysihtml5.util.setIndent(para);
                                }
                            }
                        }
                    }
                }
            }
        },

        state : function (composer, command, alignValue) {
            return false;
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.pageBreak = {
        exec : function (composer, command) {
            var range = composer.selection.getRange();
            var textNodes;
            if (range) {
                textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            }
            /* Fallback in case the text is not selected but cursor is focused on the text*/
            if (textNodes == null || textNodes.length == 0) {
                var selectedNode = composer.selection.getSelectedNode();
                if (selectedNode) {
                    textNodes = [selectedNode];
                }
            }
            if (textNodes.length) {
                var textNode;
                for (var i = 0, len = textNodes.length;
                     i < len;
                     ++i) {
                    textNode = textNodes[i];
                    var parent = wysihtml5.dom.getParentElement(textNode, {nodeName : ["P", "H1", "H2", "H3", "H4", "H5", "H6"]});
                    if (parent) {
                        var styleAttribute = parent.getAttribute("style");
                        if (styleAttribute) {
                            var regExp1 = /page-break-inside\s*:\s*avoid;/g,
                                regExp2 = /page-break-inside\s*:\s*avoid/g; //Check for both with/without semi-colon
                            if (regExp1.exec(styleAttribute)) {
                                styleAttribute = styleAttribute.replace(regExp1, "");
                            } else if (regExp2.exec(styleAttribute)) {
                                styleAttribute = styleAttribute.replace(regExp2, "");
                            } else {
                                if (!styleAttribute.endsWith(";")) {
                                    styleAttribute += ";";
                                }
                                styleAttribute += "page-break-inside: avoid;";
                            }
                        } else {
                            styleAttribute = "page-break-inside: avoid;";
                        }
                        parent.setAttribute("style", styleAttribute);
                    }
                }
            }
        },

        state : function (composer, command) {
            var attributes = {"page-break-inside" : "avoid",
                "break-inside" : "avoid"};
            return !wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], null, null, attributes);
        }
    };
})(wysihtml5);
wysihtml5.commands.hiliteColor = {
    exec : function (composer, command, color) {
        /* After state implementation changes, use following browser command.
         if (composer.commands.support(command)) {
         composer.doc.execCommand(command, false, color);
         }*/
        var attributes = {"background-color" : color};
        return wysihtml5.commands.formatInline.exec(composer, command, "span", "wysiwyg-bgcolor-" + color, /wysiwyg-bgcolor-[0-9a-z]+/g, attributes);
    },

    state : function (composer, command, color) {
        var attributes = {"background-color" : color};
        return wysihtml5.commands.formatInline.state(composer, command, "span", "wysiwyg-bgcolor-" + color, /wysiwyg-bgcolor-[0-9a-z]+/g, attributes);
    }
};
wysihtml5.commands.redo = {
    exec : function (composer) {
        return composer.undoManager.redo();
    },

    state : function (composer) {
        return false;
    }
};
wysihtml5.commands.underline = {
    exec : function (composer, command) {
        return wysihtml5.commands.formatInline.exec(composer, command, "u");
    },

    state : function (composer, command) {
        return wysihtml5.commands.formatInline.state(composer, command, "u");
    }
};
wysihtml5.commands.undo = {
    exec : function (composer) {
        return composer.undoManager.undo();
    },

    state : function (composer) {
        return false;
    }
};
/**
 * Undo Manager for wysihtml5
 * slightly inspired by http://rniwa.com/editing/undomanager.html#the-undomanager-interface
 */
(function (wysihtml5) {
    var Z_KEY = 90,
        Y_KEY = 89,
        BACKSPACE_KEY = 8,
        DELETE_KEY = 46,
        MAX_HISTORY_ENTRIES = 25,
        DATA_ATTR_NODE = "data-wysihtml5-selection-node",
        DATA_ATTR_OFFSET = "data-wysihtml5-selection-offset",
        UNDO_HTML = '<span id="_wysihtml5-undo" class="_wysihtml5-temp">' + wysihtml5.INVISIBLE_SPACE + '</span>',
        REDO_HTML = '<span id="_wysihtml5-redo" class="_wysihtml5-temp">' + wysihtml5.INVISIBLE_SPACE + '</span>',
        dom = wysihtml5.dom;

    function cleanTempElements(doc) {
        var tempElement;
        while (tempElement = doc.querySelector("._wysihtml5-temp")) {
            tempElement.parentNode.removeChild(tempElement);
        }
    }

    wysihtml5.UndoManager = wysihtml5.lang.Dispatcher.extend(
        /** @scope wysihtml5.UndoManager.prototype */ {
            constructor : function (editor) {
                this.editor = editor;
                this.composer = editor.composer;
                this.element = this.composer.element;

                this.position = 0;
                this.historyStr = [];
                this.historyDom = [];

                this.transact();

                this._observe();
            },
            clearHistory : function () {
                this.position = 0;
                this.historyStr = [];
                this.historyDom = [];
            },

            _observe : function () {
                var that = this,
                    doc = this.composer.sandbox.getDocument(),
                    lastKey;

                // Catch CTRL+Z and CTRL+Y
                dom.observe(this.element, "keydown", function (event) {
                    if (event.altKey || (!event.ctrlKey && !event.metaKey)) {
                        return;
                    }

                    var keyCode = event.keyCode,
                        isUndo = keyCode === Z_KEY && !event.shiftKey,
                        isRedo = (keyCode === Z_KEY && event.shiftKey) || (keyCode === Y_KEY);

                    if (isUndo) {
                        that.undo();
                        event.preventDefault();
                    } else if (isRedo) {
                        that.redo();
                        event.preventDefault();
                    }
                });

                // Catch delete and backspace
                dom.observe(this.element, "keydown", function (event) {
                    var keyCode = event.keyCode;
                    if (keyCode === lastKey) {
                        return;
                    }

                    lastKey = keyCode;

                    if (keyCode === BACKSPACE_KEY || keyCode === DELETE_KEY) {
                        that.transact();
                    }
                });

                // Now this is very hacky:
                // These days browsers don't offer a undo/redo event which we could hook into
                // to be notified when the user hits undo/redo in the contextmenu.
                // Therefore we simply insert two elements as soon as the contextmenu gets opened.
                // The last element being inserted will be immediately be removed again by a exexCommand("undo")
                //  => When the second element appears in the dom tree then we know the user clicked "redo" in the context menu
                //  => When the first element disappears from the dom tree then we know the user clicked "undo" in the context menu
                if (wysihtml5.browser.hasUndoInContextMenu()) {
                    var interval, observed, cleanUp = function () {
                        cleanTempElements(doc);
                        clearInterval(interval);
                    };

                    dom.observe(this.element, "contextmenu", function () {
                        cleanUp();
                        that.composer.selection.executeAndRestoreSimple(function () {
                            if (that.element.lastChild) {
                                that.composer.selection.setAfter(that.element.lastChild);
                            }

                            // enable undo button in context menu
                            doc.execCommand("insertHTML", false, UNDO_HTML);
                            // enable redo button in context menu
                            doc.execCommand("insertHTML", false, REDO_HTML);
                            doc.execCommand("undo", false, null);
                        });

                        interval = setInterval(function () {
                            if (doc.getElementById("_wysihtml5-redo")) {
                                cleanUp();
                                that.redo();
                            } else if (!doc.getElementById("_wysihtml5-undo")) {
                                cleanUp();
                                that.undo();
                            }
                        }, 400);

                        if (!observed) {
                            observed = true;
                            dom.observe(document, "mousedown", cleanUp);
                            dom.observe(doc, ["mousedown", "paste", "cut", "copy"], cleanUp);
                        }
                    });
                }

                this.editor
                    .on("newword:composer", function () {
                        that.transact();
                    })

                    .on("beforecommand:composer", function () {
                        that.transact();
                    });
            },

            transact : function () {
                var previousHtml = this.historyStr[this.position - 1],
                    currentHtml = this.composer.getValue();

                if (currentHtml === previousHtml) {
                    return;
                }

                var length = this.historyStr.length = this.historyDom.length = this.position;
                if (length > MAX_HISTORY_ENTRIES) {
                    this.historyStr.shift();
                    this.historyDom.shift();
                    this.position--;
                }

                this.position++;

                var range = this.composer.selection.getRange(),
                    node = range.startContainer || this.element,
                    offset = range.startOffset || 0,
                    element,
                    position;

                if (node.nodeType === wysihtml5.ELEMENT_NODE) {
                    element = node;
                } else {
                    element = node.parentNode;
                    position = this.getChildNodeIndex(element, node);
                }

                element.setAttribute(DATA_ATTR_OFFSET, offset);
                if (typeof(position) !== "undefined") {
                    element.setAttribute(DATA_ATTR_NODE, position);
                }

                var clone = this.element.cloneNode(!!currentHtml);
                this.historyDom.push(clone);
                this.historyStr.push(currentHtml);

                element.removeAttribute(DATA_ATTR_OFFSET);
                element.removeAttribute(DATA_ATTR_NODE);
            },

            undo : function () {
                this.transact();

                if (!this.undoPossible()) {
                    return;
                }

                this.set(this.historyDom[--this.position - 1]);
                this.editor.fire("undo:composer");
            },

            redo : function () {
                if (!this.redoPossible()) {
                    return;
                }

                this.set(this.historyDom[++this.position - 1]);
                this.editor.fire("redo:composer");
            },

            undoPossible : function () {
                return this.position > 1;
            },

            redoPossible : function () {
                return this.position < this.historyStr.length;
            },

            set : function (historyEntry) {
                this.element.innerHTML = "";

                var i = 0,
                    childNodes = historyEntry.childNodes,
                    length = historyEntry.childNodes.length;

                for (;
                    i < length;
                    i++) {
                    this.element.appendChild(childNodes[i].cloneNode(true));
                }

                // Restore selection
                var offset,
                    node,
                    position;

                if (historyEntry.hasAttribute(DATA_ATTR_OFFSET)) {
                    offset = historyEntry.getAttribute(DATA_ATTR_OFFSET);
                    position = historyEntry.getAttribute(DATA_ATTR_NODE);
                    node = this.element;
                } else {
                    node = this.element.querySelector("[" + DATA_ATTR_OFFSET + "]") || this.element;
                    offset = node.getAttribute(DATA_ATTR_OFFSET);
                    position = node.getAttribute(DATA_ATTR_NODE);
                    node.removeAttribute(DATA_ATTR_OFFSET);
                    node.removeAttribute(DATA_ATTR_NODE);
                }

                if (position !== null) {
                    node = this.getChildNodeByIndex(node, +position);
                }

                this.composer.selection.set(node, offset);
            },

            getChildNodeIndex : function (parent, child) {
                var i = 0,
                    childNodes = parent.childNodes,
                    length = childNodes.length;
                for (;
                    i < length;
                    i++) {
                    if (childNodes[i] === child) {
                        return i;
                    }
                }
            },

            getChildNodeByIndex : function (parent, index) {
                return parent.childNodes[index];
            }
        });
})(wysihtml5);
/**
 * TODO: the following methods still need unit test coverage
 */
wysihtml5.views.View = Base.extend(
    /** @scope wysihtml5.views.View.prototype */ {
        constructor : function (parent, textareaElement, config) {
            this.parent = parent;
            this.element = textareaElement;
            this.config = config;

            this._observeViewChange();
        },

        _observeViewChange : function () {
            var that = this;
            this.parent.on("beforeload", function () {
                that.parent.on("change_view", function (view) {
                    if (view === that.name) {
                        that.parent.currentView = that;
                        that.show();
                        // Using tiny delay here to make sure that the placeholder is set before focusing
                        setTimeout(function () {
                            that.focus();
                        }, 0);
                    } else {
                        that.hide();
                    }
                });
            });
        },

        focus : function () {
            if (this.element.ownerDocument.querySelector(":focus") === this.element) {
                return;
            }

            try {
                this.element.focus();
            } catch (e) {
            }
        },

        hide : function () {
            this.element.style.display = "none";
        },

        show : function () {
            this.element.style.display = "";
        },

        disable : function () {
            this.element.setAttribute("disabled", "disabled");
        },

        enable : function () {
            this.element.removeAttribute("disabled");
        }
    });
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        browser = wysihtml5.browser;

    wysihtml5.views.Composer = wysihtml5.views.View.extend(
        /** @scope wysihtml5.views.Composer.prototype */ {
            name : "composer",

            // Needed for firefox in order to display a proper caret in an empty contentEditable
            CARET_HACK : "<br>",

            constructor : function (parent, textareaElement, config) {
                this.base(parent, textareaElement, config);
                this.textarea = this.parent.textarea;
                this._initSandbox(config.insertAfter);
            },

            clear : function () {
                this.element.innerHTML = browser.displaysCaretInEmptyContentEditableCorrectly() ? "" : this.CARET_HACK;
            },

            getValue : function (parse) {
                var value = this.isEmpty() ? "" : wysihtml5.quirks.getCorrectInnerHTML(this.element);

                if (parse) {
                    value = this.parent.parse(value);
                }

                // Replace all "zero width no breaking space" chars
                // which are used as hacks to enable some functionalities
                // Also remove all CARET hacks that somehow got left
                value = wysihtml5.lang.string(value).replace(wysihtml5.INVISIBLE_SPACE).by("");

                return value;
            },

            setValue : function (html, parse) {
                if (parse) {
                    html = this.parent.parse(html);
                }

                try {
                    this.element.innerHTML = html;
                } catch (e) {
                    this.element.innerText = html;
                }
            },

            show : function () {
                this.container.style.display = this._displayStyle || "";

                if (!this.textarea.element.disabled) {
                    // Firefox needs this, otherwise contentEditable becomes uneditable
                    this.disable();
                    this.enable();
                }
            },

            hide : function () {
                this._displayStyle = dom.getStyle("display").from(this.container);
                if (this._displayStyle === "none") {
                    this._displayStyle = null;
                }
                this.container.style.display = "none";
            },

            disable : function () {
                this.parent.fire("disable:composer");
                this.element.removeAttribute("contentEditable");
            },

            enable : function () {
                this.parent.fire("enable:composer");
                this.element.setAttribute("contentEditable", "true");
            },

            focus : function (setToEnd) {
                // IE 8 fires the focus event after .focus()
                // This is needed by our simulate_placeholder.js to work
                // therefore we clear it ourselves this time
                if (wysihtml5.browser.doesAsyncFocus() && this.hasPlaceholderSet()) {
                    this.clear();
                }

                this.base();

                var lastChild = this.element.lastChild;
                if (setToEnd && lastChild) {
                    if (lastChild.nodeName === "BR") {
                        this.selection.setBefore(this.element.lastChild);
                    } else {
                        this.selection.setAfter(this.element.lastChild);
                    }
                }
            },

            getTextContent : function () {
                return dom.getTextContent(this.element);
            },

            applyStyle : function (composer, styleProperties, attributes) {
                var selectedNodes = composer.selection.getNodes(1);
                var applyStyleToNode = function (node) {
                    if (node != null) {
                        var parentNode = dom.getParentElement(node, {nodeName : ["LI"]});
                        if (parentNode != null) {
                            /* Prevent applying style to inner lists*/
                            var listNode = dom.getParentElement(node, {nodeName : ["OL", "UL"]});
                            if (listNode != null && selectedNodes.indexOf(listNode) > 0) {
                                var parentListItem = dom.getParentElement(listNode, {nodeName : ["LI"]});
                                if (parentListItem != null && selectedNodes.indexOf(parentListItem) > 0) {
                                    return;
                                }
                            }
                            node = parentNode;
                        }
                        for (var property in styleProperties) {
                            node.style.setProperty(property, styleProperties[property]);
                        }
                        for (var attribute in attributes) {
                            node.setAttribute(attribute, attributes[attribute]);
                        }
                    }
                };
                var nodeList = composer.selection.getNodes(3);
                if (nodeList.length > 0) {
                    for (i = 0;
                         i < nodeList.length;
                         i++) {
                        var node = nodeList[i];
                        if (node != null) {
                            node = node.parentNode;
                            if (node != null && (node.nodeName == "P" || node.nodeName == "LI" || node.nodeName.match(/^H[1-6]$/))) {
                                applyStyleToNode(node);
                            } else if (node != null && !wysihtml5.util.isEditorNode(node)) {
                                while (node != null && node.nodeName != "P" && node.nodeName != "LI" && node.nodeName.match(/^H[1-6]$/) == null) {
                                    node = node.parentElement;
                                }
                                applyStyleToNode(node);
                            }
                        }
                    }
                } else {
                    var selectedNode = composer.selection.getSelectedNode();
                    while (selectedNode != null && selectedNode.nodeName != "P" && selectedNode.nodeName != selectedNode.nodeName.match(/^H[1-6]$/)) {
                        selectedNode = selectedNode.parentElement ? selectedNode.parentElement : selectedNode.parentNode;
                    }
                    applyStyleToNode(selectedNode);
                }
            },
            hasPlaceholderSet : function () {
                return this.getTextContent() == this.textarea.element.getAttribute("placeholder") && this.placeholderSet;
            },

            isEmpty : function () {
                var innerHTML = this.element.innerHTML.toLowerCase();
                return innerHTML === "" ||
                    innerHTML === "<br>" ||
                    innerHTML === "<p></p>" ||
                    innerHTML === "<p><br></p>" ||
                    this.hasPlaceholderSet();
            },

            _initSandbox : function (insertAfter) {

                this.sandbox = new dom.Sandbox({
                    stylesheets : this.config.stylesheets
                });
                this.container = this.sandbox.getContainer();

                var textareaElement = this.textarea.element;
                insertAfter = insertAfter || textareaElement;
                dom.insert(this.container).after(insertAfter);

                // Create hidden field which tells the server after submit, that the user used an wysiwyg editor
                if (textareaElement.form) {
                    var hiddenField = document.createElement("input");
                    hiddenField.type = "hidden";
                    hiddenField.name = "_wysihtml5_mode";
                    hiddenField.value = 1;
                    dom.insert(hiddenField).after(textareaElement);
                }
            },

            _create : function () {
                var that = this;

                this.doc = this.sandbox.getDocument();
                this.element = this.container;
                this.textarea = this.parent.textarea;
                this.element.innerHTML = this.textarea.getValue(true);

                // Make sure our selection handler is ready
                this.selection = new wysihtml5.Selection(this.parent);

                // Make sure commands dispatcher is ready
                this.commands = new wysihtml5.Commands(this.parent);

                dom.copyAttributes([
                    "className", "spellcheck", "title", "lang", "accessKey"
                ]).from(this.textarea.element).to(this.element);

                dom.addClass(this.element, this.config.composerClassName);
                //
                // // Make the editor look like the original textarea, by syncing styles
                if (this.config.style) {
                    this.style();
                }

                this.observe();

                var name = this.config.name;
                if (name) {
                    dom.addClass(this.element, name);
                }

                this.enable();

                if (this.textarea.element.disabled) {
                    this.disable();
                }

                // Simulate html5 placeholder attribute on contentEditable element
                var placeholderText = typeof(this.config.placeholder) === "string" ? this.config.placeholder : this.textarea.element.getAttribute("placeholder");
                if (placeholderText) {
                    dom.simulatePlaceholder(this.parent, this, placeholderText);
                }

                // Make sure that the browser avoids using inline styles whenever possible
                this.commands.exec("styleWithCSS", false);

                this._initAutoLinking();
                this._initObjectResizing();
                this._initUndoManager();
                this._initLineBreaking();

                // Simulate html5 autofocus on contentEditable element
                // This doesn't work on IOS (5.1.1)
                if ((this.textarea.element.hasAttribute("autofocus") || document.querySelector(":focus") == this.textarea.element) && !browser.isIos()) {
                    setTimeout(function () {
                        that.focus(true);
                    }, 100);
                }

                // IE sometimes leaves a single paragraph, which can't be removed by the user
                if (!browser.clearsContentEditableCorrectly()) {
                    wysihtml5.quirks.ensureProperClearing(this);
                }

                // Set up a sync that makes sure that textarea and editor have the same content
                if (this.initSync && this.config.sync) {
                    this.initSync();
                }

                // Okay hide the textarea, we are ready to go
                this.textarea.hide();

                var parent = this.parent;
                // Fire global (before-)load event
                setTimeout(function () {
                    parent.fire("beforeload").fire("load");
                }, 0);
            },

            _initAutoLinking : function () {
                var that = this,
                    supportsDisablingOfAutoLinking = browser.canDisableAutoLinking(),
                    supportsAutoLinking = browser.doesAutoLinkingInContentEditable();
                if (supportsDisablingOfAutoLinking) {
                    this.commands.exec("autoUrlDetect", false);
                }

                if (!this.config.autoLink) {
                    return;
                }

                // Only do the auto linking by ourselves when the browser doesn't support auto linking
                // OR when he supports auto linking but we were able to turn it off (IE9+)
                if (!supportsAutoLinking || (supportsAutoLinking && supportsDisablingOfAutoLinking)) {
                    this.parent.on("newword:composer", function () {
                        if (dom.getTextContent(that.element).match(dom.autoLink.URL_REG_EXP)) {
                            that.selection.executeAndRestore(function (startContainer, endContainer) {
                                dom.autoLink(endContainer.parentNode);
                            });
                        }
                    });

                    dom.observe(this.element, "blur", function () {
                        dom.autoLink(that.element);
                    });
                }

                // Assuming we have the following:
                //  <a href="http://www.google.de">http://www.google.de</a>
                // If a user now changes the url in the innerHTML we want to make sure that
                // it's synchronized with the href attribute (as long as the innerHTML is still a url)
                var // Use a live NodeList to check whether there are any links in the document
                    links = this.sandbox.getDocument().getElementsByTagName("a"),
                    // The autoLink helper method reveals a reg exp to detect correct urls
                    urlRegExp = dom.autoLink.URL_REG_EXP,
                    getTextContent = function (element) {
                        var textContent = wysihtml5.lang.string(dom.getTextContent(element)).trim();
                        if (textContent.substr(0, 4) === "www.") {
                            textContent = "http://" + textContent;
                        }
                        return textContent;
                    };

                dom.observe(this.element, "keydown", function (event) {
                    if (!links.length) {
                        return;
                    }

                    var selectedNode = that.selection.getSelectedNode(event.target.ownerDocument),
                        link = dom.getParentElement(selectedNode, {nodeName : "A"}, 4),
                        textContent;

                    if (!link) {
                        return;
                    }

                    textContent = getTextContent(link);
                    // keydown is fired before the actual content is changed
                    // therefore we set a timeout to change the href
                    setTimeout(function () {
                        var newTextContent = getTextContent(link);
                        if (newTextContent === textContent) {
                            return;
                        }

                        // Only set href when new href looks like a valid url
                        if (newTextContent.match(urlRegExp)) {
                            link.setAttribute("href", newTextContent);
                        }
                    }, 0);
                });
            },

            _initObjectResizing : function () {
                this.commands.exec("enableObjectResizing", true);

                // IE sets inline styles after resizing objects
                // The following lines make sure that the width/height css properties
                // are copied over to the width/height attributes
                if (browser.supportsEvent("resizeend")) {
                    var properties = ["width", "height"],
                        propertiesLength = properties.length,
                        element = this.element;

                    dom.observe(element, "resizeend", function (event) {
                        var target = event.target || event.srcElement,
                            style = target.style,
                            i = 0,
                            property;

                        if (target.nodeName !== "IMG") {
                            return;
                        }

                        for (;
                            i < propertiesLength;
                            i++) {
                            property = properties[i];
                            if (style[property]) {
                                target.setAttribute(property, parseInt(style[property], 10));
                                style[property] = "";
                            }
                        }

                        // After resizing IE sometimes forgets to remove the old resize handles
                        wysihtml5.quirks.redraw(element);
                    });
                }
            },

            _initUndoManager : function () {
                this.undoManager = new wysihtml5.UndoManager(this.parent);
            },

            _initLineBreaking : function () {
                var that = this,
                    USE_NATIVE_LINE_BREAK_INSIDE_TAGS = ["LI", "P", "H1", "H2", "H3", "H4", "H5", "H6"],
                    LIST_TAGS = ["UL", "OL", "MENU"];

                function adjust(selectedNode) {
                    var parentElement = dom.getParentElement(selectedNode, {nodeName : ["P", "DIV", "H1", "H2", "H3", "H4", "H5", "H6"]}, 2);
                    if (parentElement && (parentElement.nodeName == "DIV" || !parentElement.textContent || parentElement.textContent.trim() == "")) {
                        that.selection.executeAndRestore(function () {
                            if (that.config.useLineBreaks) {
                                dom.replaceWithChildNodes(parentElement);
                            } else if (parentElement.nodeName !== "P") {
                                dom.renameElement(parentElement, "p");
                            }
                        });
                    }
                }

                if (!this.config.useLineBreaks) {
                    dom.observe(this.element, ["focus", "keydown"], function () {
                        if (that.isEmpty()) {
                            var paragraph = that.doc.createElement("P");
                            that.element.innerHTML = "";
                            that.element.appendChild(paragraph);
                            var span = that.doc.createElement("span");
                            paragraph.appendChild(span);
                            if (!browser.displaysCaretInEmptyContentEditableCorrectly()) {
                                span.innerHTML = "<br>";
                            }
                            that.selection.selectNode(span, true);
                        }
                    });
                }

                dom.observe(this.element, "keydown", function (event) {
                    var keyCode = event.keyCode;

                    if (event.shiftKey) {
                        return;
                    }

                    if (keyCode !== wysihtml5.ENTER_KEY && keyCode !== wysihtml5.BACKSPACE_KEY) {
                        return;
                    }

                    var blockElement = dom.getParentElement(that.selection.getSelectedNode(), {nodeName : USE_NATIVE_LINE_BREAK_INSIDE_TAGS});

                    if (blockElement) {
                        setTimeout(function () {
                            // Unwrap paragraph after leaving a list or a H1-6
                            var selectedNode = that.selection.getSelectedNode(),
                                list;
                            //Fixing for LC-3910682 : [Text Editor] - New 'help content' symbol gets added when user press enter after a 'help content' symbol
                            // Its hacky method but didnt find who is copying the style & class name on creating new node
                            var className = "textEditor-customDataAttr";
                            if (selectedNode && selectedNode.className && selectedNode.className.indexOf(className) != -1) {
                                selectedNode.className = selectedNode.className.replace(className, "");
                                var data = $(selectedNode).data();
                                for (var key in data) {
                                    $(selectedNode).removeData(key);
                                    $(selectedNode).removeAttr("data-" + key);
                                }
                            }
                            if (that.config && that.config.parserRules && that.config.parserRules.pseudoTags) {
                                var nodeNames = that.config.parserRules.pseudoTags.map(function (tag) {
                                    if (tag) {
                                        return tag.toUpperCase();
                                    }
                                });
                                var pseudoNode = dom.getParentElement(selectedNode, {nodeName : nodeNames});
                                if (pseudoNode && !pseudoNode.textContent) {
                                    pseudoNode.outerHTML = "<span>" + pseudoNode.innerHTML + "</span>";
                                }
                            }

                            if (blockElement.nodeName === "LI") {
                                if (!selectedNode) {
                                    return;
                                }

                                list = dom.getParentElement(selectedNode, {nodeName : LIST_TAGS}, 2);

                                if (!list) {
                                    adjust(selectedNode);
                                }
                            }

                            if (keyCode === wysihtml5.ENTER_KEY && blockElement.nodeName.match(/^H[1-6]$/)) {
                                adjust(selectedNode);
                            }

                            // Refetching the selected node as it may be modifed by adjust
                            selectedNode = that.selection.getSelectedNode();
                            // Make sure that every paragraph & LI have span element
                            var matchingNodes = ["P", "LI", "DIV"];
                            if (selectedNode) {
                                var emptList = [];
                                for (var index = 0;
                                     index < matchingNodes.length;
                                     index++) {
                                    var nodeName = matchingNodes[index];
                                    var tagName = nodeName.toLowerCase();
                                    if (selectedNode.nodeName === nodeName) {
                                        emptList = [];
                                        emptList.push("<" + tagName + "></" + tagName + ">");
                                        emptList.push("<" + tagName + "><br></" + tagName + ">");
                                        emptList.push("<" + tagName + "><br></br></" + tagName + ">");
                                        // check if node is empty ( empty include <br> case also)
                                        if (emptList.indexOf(selectedNode.outerHTML) > -1) {
                                            var span = that.doc.createElement("span");
                                            if (!browser.displaysCaretInEmptyContentEditableCorrectly()) {
                                                span.innerHTML = "<br>";
                                            }
                                            // Remove <BR> if any
                                            while (selectedNode.firstChild) {
                                                selectedNode.removeChild(selectedNode.firstChild);
                                            }
                                            selectedNode.appendChild(span);
                                            if (selectedNode.nodeName === "DIV") {// Make sure we have only P or LI tags
                                                dom.renameElement(selectedNode, "p");
                                            }
                                            that.selection.selectNode(span);// Forcing to focus on span other text will be insert at p or li
                                        }
                                    }
                                }
                                // Make sure that every LI have paragraph+span
                                if (selectedNode) {
                                    var parentLI = dom.getParentElement(selectedNode, {nodeName : "LI"});
                                    var parentDIV = dom.getParentElement(selectedNode, {nodeName : "DIV"});
                                    if (parentLI) {
                                        var childNode;
                                        var para = null;
                                        // Check if fist child node is paragraph : if true simple return or else move the LI content to paragraph
                                        // We are not check all the child as shift enter is used for new Line and it will create span in paragraph
                                        if (parentLI.childElementCount > 0) {
                                            childNode = parentLI.childNodes[0];
                                            if (childNode && childNode.nodeName == "P") {
                                                return;
                                            } else {
                                                para = that.doc.createElement("p");
                                                parentLI.appendChild(para);
                                            }
                                        }
                                        for (var childIndex = 0;
                                             childIndex < parentLI.childElementCount;
                                             childIndex++) {
                                            childNode = parentLI.childNodes[childIndex];
                                            if (para) {
                                                para.appendChild(childNode);
                                            }
                                        }
                                        that.selection.selectNode(childNode);// Forcing to focus on span other text will be insert at p or li
                                    }
                                    if (parentDIV && !wysihtml5.util.isEditorNode(parentDIV)) {
                                        var parsedElem = that.parent.parse(parentDIV);
                                        if (parsedElem.innerHTML) {
                                            parentDIV.outerHTML = parsedElem.innerHTML;
                                        }
                                    }
                                }
                            }
                        }, 0);
                        return;
                    }

                    if (that.config.useLineBreaks && keyCode === wysihtml5.ENTER_KEY && !wysihtml5.browser.insertsLineBreaksOnReturn()) {
                        that.commands.exec("insertLineBreak");
                        event.preventDefault();
                    }
                });
            }
        });
})(wysihtml5);
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        doc = document,
        win = window,
        HOST_TEMPLATE = doc.createElement("div"),
        /**
         * Styles to copy from textarea to the composer element
         */
        TEXT_FORMATTING = [
            "background-color",
            "color", "cursor",
            "font-family", "font-size", "font-style", "font-variant", "font-weight",
            "line-height", "letter-spacing",
            "text-align", "text-decoration", "text-indent", "text-rendering",
            "word-break", "word-wrap", "word-spacing"
        ],
        /**
         * Styles to copy from textarea to the iframe
         */
        BOX_FORMATTING = [
            "background-color",
            "border-collapse",
            "border-bottom-color", "border-bottom-style", "border-bottom-width",
            "border-left-color", "border-left-style", "border-left-width",
            "border-right-color", "border-right-style", "border-right-width",
            "border-top-color", "border-top-style", "border-top-width",
            "clear", "display", "float",
            "margin-bottom", "margin-left", "margin-right", "margin-top",
            "outline-color", "outline-offset", "outline-width", "outline-style",
            "padding-left", "padding-right", "padding-top", "padding-bottom",
            "position", "top", "left", "right", "bottom", "z-index",
            "vertical-align", "text-align",
            "-webkit-box-sizing", "-moz-box-sizing", "-ms-box-sizing", "box-sizing",
            "-webkit-box-shadow", "-moz-box-shadow", "-ms-box-shadow", "box-shadow",
            "-webkit-border-top-right-radius", "-moz-border-radius-topright", "border-top-right-radius",
            "-webkit-border-bottom-right-radius", "-moz-border-radius-bottomright", "border-bottom-right-radius",
            "-webkit-border-bottom-left-radius", "-moz-border-radius-bottomleft", "border-bottom-left-radius",
            "-webkit-border-top-left-radius", "-moz-border-radius-topleft", "border-top-left-radius",
            "width", "height", "white-space"
        ],
        ADDITIONAL_CSS_RULES = [
            "html                 { height: 100%; }",
            "body                 { height: 100%; padding: 1px 0 0 0; margin: -1px 0 0 0; }",
            "body > p:first-child { margin-top: 0; }",
            "._wysihtml5-temp     { display: none; }",
            wysihtml5.browser.isGecko ?
                "body.placeholder { color: graytext !important; }" :
                "body.placeholder { color: #a9a9a9 !important; }",
            // Ensure that user see's broken images and can delete them
            "img:-moz-broken      { -moz-force-broken-image-icon: 1; height: 24px; width: 24px; }"
        ];

    /**
     * With "setActive" IE offers a smart way of focusing elements without scrolling them into view:
     * http://msdn.microsoft.com/en-us/library/ms536738(v=vs.85).aspx
     *
     * Other browsers need a more hacky way: (pssst don't tell my mama)
     * In order to prevent the element being scrolled into view when focusing it, we simply
     * move it out of the scrollable area, focus it, and reset it's position
     */
    var focusWithoutScrolling = function (element) {
        if (element.setActive) {
            // Following line could cause a js error when the textarea is invisible
            // See https://github.com/xing/wysihtml5/issues/9
            try {
                element.setActive();
            } catch (e) {
            }
        } else {
            var elementStyle = element.style,
                originalScrollTop = doc.documentElement.scrollTop || doc.body.scrollTop,
                originalScrollLeft = doc.documentElement.scrollLeft || doc.body.scrollLeft,
                originalStyles = {
                    position : elementStyle.position,
                    top : elementStyle.top,
                    left : elementStyle.left,
                    WebkitUserSelect : elementStyle.WebkitUserSelect
                };

            dom.setStyles({
                position : "absolute",
                top : "-99999px",
                left : "-99999px",
                // Don't ask why but temporarily setting -webkit-user-select to none makes the whole thing performing smoother
                WebkitUserSelect : "none"
            }).on(element);

            element.focus();

            dom.setStyles(originalStyles).on(element);

            if (win.scrollTo) {
                // Some browser extensions unset this method to prevent annoyances
                // "Better PopUp Blocker" for Chrome http://code.google.com/p/betterpopupblocker/source/browse/trunk/blockStart.js#100
                // Issue: http://code.google.com/p/betterpopupblocker/issues/detail?id=1
                win.scrollTo(originalScrollLeft, originalScrollTop);
            }
        }
    };

    wysihtml5.views.Composer.prototype.style = function () {
        var that = this,
            originalActiveElement = doc.querySelector(":focus"),
            textareaElement = this.textarea.element,
            hasPlaceholder = textareaElement.hasAttribute("placeholder"),
            originalPlaceholder = hasPlaceholder && textareaElement.getAttribute("placeholder"),
            originalDisplayValue = textareaElement.style.display,
            originalDisabled = textareaElement.disabled,
            displayValueForCopying;

        this.focusStylesHost = HOST_TEMPLATE.cloneNode(false);
        this.blurStylesHost = HOST_TEMPLATE.cloneNode(false);
        this.disabledStylesHost = HOST_TEMPLATE.cloneNode(false);

        // Remove placeholder before copying (as the placeholder has an affect on the computed style)
        if (hasPlaceholder) {
            textareaElement.removeAttribute("placeholder");
        }

        if (textareaElement === originalActiveElement) {
            textareaElement.blur();
        }

        // enable for copying styles
        textareaElement.disabled = false;

        // set textarea to display="none" to get cascaded styles via getComputedStyle
        textareaElement.style.display = displayValueForCopying = "none";
        textareaElement.style.visibility = "hidden";

        if ((textareaElement.getAttribute("rows") && dom.getStyle("height").from(textareaElement) === "auto") ||
            (textareaElement.getAttribute("cols") && dom.getStyle("width").from(textareaElement) === "auto")) {
            textareaElement.style.display = displayValueForCopying = originalDisplayValue;
        }

        // --------- container styles (has to be set before editor styles, otherwise IE9 sets wrong fontFamily on blurStylesHost) ---------
        dom.copyStyles(BOX_FORMATTING).from(textareaElement).to(this.container).andTo(this.blurStylesHost);

        // --------- editor styles ---------
        dom.copyStyles(TEXT_FORMATTING).from(textareaElement).to(this.element).andTo(this.blurStylesHost);

        // --------- apply standard rules ---------
        dom.insertCSS(ADDITIONAL_CSS_RULES).into(this.element.ownerDocument);

        // --------- :disabled styles ---------
        textareaElement.disabled = true;
        dom.copyStyles(BOX_FORMATTING).from(textareaElement).to(this.disabledStylesHost);
        dom.copyStyles(TEXT_FORMATTING).from(textareaElement).to(this.disabledStylesHost);
        textareaElement.disabled = originalDisabled;

        // --------- :focus styles ---------
        textareaElement.style.display = originalDisplayValue;
        focusWithoutScrolling(textareaElement);
        textareaElement.style.display = displayValueForCopying;

        dom.copyStyles(BOX_FORMATTING).from(textareaElement).to(this.focusStylesHost);
        dom.copyStyles(TEXT_FORMATTING).from(textareaElement).to(this.focusStylesHost);

        // reset textarea
        textareaElement.style.display = originalDisplayValue;

        dom.copyStyles(["display"]).from(textareaElement).to(this.container);

        // Make sure that we don't change the display style of the container when copying styles oblur/onfocus
        // this is needed for when the change_view event is fired where the container is hidden and then
        // the blur event fires and re-displays it
        var boxFormattingStyles = wysihtml5.lang.array(BOX_FORMATTING).without(["display"]);

        // --------- restore focus ---------
        if (originalActiveElement) {
            originalActiveElement.focus();
        } else {
            textareaElement.blur();
        }

        // --------- restore placeholder ---------
        if (hasPlaceholder) {
            textareaElement.setAttribute("placeholder", originalPlaceholder);
        }

        // --------- Sync focus/blur styles ---------

        this.parent.on("blur:composer", function () {
            // Fixing LC-3911994
            this.savedSelection = this.composer.selection.getCurrentRange();
        });

        this.parent.observe("disable:composer", function () {
            dom.copyStyles(boxFormattingStyles).from(that.disabledStylesHost).to(that.container);
            dom.copyStyles(TEXT_FORMATTING).from(that.disabledStylesHost).to(that.element);
        });

        this.parent.observe("enable:composer", function () {
            dom.copyStyles(boxFormattingStyles).from(that.blurStylesHost).to(that.container);
            dom.copyStyles(TEXT_FORMATTING).from(that.blurStylesHost).to(that.element);
        });

        return this;
    };
})(wysihtml5);
/**
 * Taking care of events
 *  - Simulating 'change' event on contentEditable element
 *  - Handling drag & drop logic
 *  - Catch paste events
 *  - Dispatch proprietary newword:composer event
 *  - Keyboard shortcuts
 */
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        browser = wysihtml5.browser,
        /**
         * Map keyCodes to query commands
         */
        shortcuts = {
            "66" : "bold",     // B
            "73" : "italic",   // I
            "85" : "underline" // U
        };

    wysihtml5.views.Composer.prototype.observe = function () {
        var that = this,
            state = this.getValue(),
            container = this.sandbox.getContainer(),
            element = this.element,
            focusBlurElement = browser.supportsEventsInIframeCorrectly() ? element : this.sandbox.getWindow(),
            pasteEvents = ["drop", "paste"];

        // --------- destroy:composer event ---------
        dom.observe(container, "DOMNodeRemoved", function (e) {
            if (e.target == this) { //Destroy composer only if the entire RTE container is removed
                clearInterval(domNodeRemovedInterval);
                that.parent.fire("destroy:composer");
            }
        });

        // DOMNodeRemoved event is not supported in IE 8
        var domNodeRemovedInterval = setInterval(function () {
            if (!dom.contains(document.documentElement, container)) {
                clearInterval(domNodeRemovedInterval);
                that.parent.fire("destroy:composer");
            }
        }, 250);

        // --------- Focus & blur logic ---------
        dom.observe(focusBlurElement, "focus", function () {
            that.parent.fire("focus").fire("focus:composer");

            // Delay storing of state until all focus handler are fired
            // especially the one which resets the placeholder
            setTimeout(function () {
                state = that.getValue();
            }, 0);
        });

        dom.observe(focusBlurElement, "click", function () {
            that.parent.fire("click:composer");
        });

        dom.observe(focusBlurElement, "blur", function () {
            if (state !== that.getValue()) {
                that.parent.fire("change").fire("change:composer");
            }
            that.parent.fire("blur").fire("blur:composer");
        });

        // --------- Drag & Drop logic ---------
        dom.observe(element, "dragenter", function () {
            that.parent.fire("unset_placeholder");
        });

        if (wysihtml5.browser.isIE) {
            dom.observe(element, "beforepaste", function (event) {
                var selection = that.parent.composer.selection.getCurrentRange();
                var tempContainer = $("<div class='wysihtml5-tempContainer' contenteditable='true'></div>")[0];
                document.body.appendChild(tempContainer);
                $(tempContainer).one("paste", function () {
                    event.preventDefault();
                    var content = "";
                    var self = this;
                    setTimeout(function () {
                        if (that.config.pasteAsPlainText) {
                            content = self.textContent;
                        } else {
                            content = self.innerHTML;
                        }
                        content = that.parent.parse(content, true);
                        that.parent.focus(false);
                        that.parent.composer.selection.setSelection(selection);
                        that.commands.exec("delete");
                        that.parent.composer.selection.insertHTML(content);
                        $(self).remove();
                        setTimeout(function () {
                            that.parent.fire("paste").fire("paste:composer", event);
                        }, 0);
                    }, 0);
                });
                tempContainer.focus();
            });

            $(that.parent.composer.doc.defaultView).on('focus', function () {
                var selection = that.parent.composer.doc.getSelection();
                if (!selection || !selection.focusNode) {
                    that.parent.composer.focus(false);
                    if (that.parent.savedSelection) {
                        that.parent.composer.selection.setSelection(that.parent.savedSelection);
                    }
                }
            });
        }

        dom.observe(element, pasteEvents, function (event) {
            if (that.config.pasteAsPlainText) {
                event.preventDefault();
                var content = "";
                if (event && event.clipboardData) {
                    content = (event.originalEvent || event).clipboardData.getData('text/plain');
                } else if (window.clipboardData) {
                    content = window.clipboardData.getData('Text');
                }
                if (content) {
                    that.commands.exec.call(that.commands, "insertText", content);
                }
            } else {
                var html = "";
                if (event && event.clipboardData) {
                    html = (event.originalEvent || event).clipboardData.getData('text/html');
                }
                if (html) {
                    event.preventDefault();
                    if (that.selection.getText()) {
                        that.commands.exec("delete");
                    }

                    /* Extract body content if body present, to remove unwanted data*/
                    var re = XRegExp("<body[^>]*>\\s*(.*)\\s*<\/body>", "gs");
                    var result = re.exec(html);

                    if (result && result.length > 1) {
                        html = result[1];
                    }
                    html = that.parent.parse(html, true);
                    that.parent.composer.selection.insertHTML(html);
                }
                setTimeout(function () {
                    that.parent.fire("paste").fire("paste:composer", event);
                }, 0);
            }
        });

        // --------- neword event ---------
        dom.observe(element, "keyup", function (event) {
            var keyCode = event.keyCode;
            if (keyCode === wysihtml5.SPACE_KEY || keyCode === wysihtml5.ENTER_KEY) {
                that.parent.fire("newword:composer");
            }
        });

        this.parent.on("paste:composer", function () {
            setTimeout(function () {
                that.parent.fire("newword:composer");
            }, 0);
        });

        // --------- Make sure that images are selected when clicking on them ---------
        if (!browser.canSelectImagesInContentEditable()) {
            dom.observe(element, "mousedown", function (event) {
                var target = event.target;
                if (target.nodeName === "IMG") {
                    that.selection.selectNode(target);
                    event.preventDefault();
                }
            });
        }

        if (browser.hasHistoryIssue() && browser.supportsSelectionModify()) {
            dom.observe(element, "keydown", function (event) {
                if (!event.metaKey && !event.ctrlKey) {
                    return;
                }

                var keyCode = event.keyCode,
                    win = element.ownerDocument.defaultView,
                    selection = win.getSelection();

                if (keyCode === 37 || keyCode === 39) {
                    if (keyCode === 37) {
                        selection.modify("extend", "left", "lineboundary");
                        if (!event.shiftKey) {
                            selection.collapseToStart();
                        }
                    }
                    if (keyCode === 39) {
                        selection.modify("extend", "right", "lineboundary");
                        if (!event.shiftKey) {
                            selection.collapseToEnd();
                        }
                    }
                    event.preventDefault();
                }
            });
        }

        // --------- Shortcut logic ---------
        dom.observe(element, "keydown", function (event) {
            var keyCode = event.keyCode,
                command = shortcuts[keyCode];
            if ((event.ctrlKey || event.metaKey) && !event.altKey && command) {
                that.commands.exec(command);
                event.preventDefault();
            }
        });

        /* Handing Tab key : Insert tab into text and prevent losing the focus from textarea. */
        dom.observe(element, "keydown", function (event) {

            if (event.keyCode == wysihtml5.TAB_KEY) {
                that.commands.exec.call(that.commands, "insertText", '\t');
                /* For handling IE */
                if (wysihtml5.browser.hasIframeFocusIssue()) {
                    var target = that.selection ? that.selection.getSelectedNode() : null;
                    if (target) {
                        var parent = target.parentNode;
                        if (parent && parent.style) {
                            parent.style.whiteSpace = "pre";
                        } else {
                            parent.setAttribute("style", "white-space: pre");
                        }
                    }
                }
                event.preventDefault();
            }
        });

        // --------- Make sure that when pressing backspace/delete on selected images deletes the image and it's anchor ---------
        dom.observe(element, "keydown", function (event) {
            var target = that.selection.getSelectedNode(true),
                keyCode = event.keyCode,
                parent;
            if (target && (keyCode === wysihtml5.BACKSPACE_KEY || keyCode === wysihtml5.DELETE_KEY)) {// 8 => backspace, 46 => delete
                var nodeNames = [];
                /* Delete configured text nodes as they are not editable and won't be deleted */
                if (that.config.parserRules && that.config.parserRules.textNodes) {
                    nodeNames = that.config.parserRules.textNodes;
                }
                nodeNames.push("IMG");
                if (nodeNames.indexOf(target.nodeName) > -1) {
                    parent = target.parentNode;
                    parent.removeChild(target);
                    if (target.nodeName === "IMG") {
                        // and it's parent <a> too if it hasn't got any other child nodes
                        if (parent.nodeName === "A" && !parent.firstChild) {
                            parent.parentNode.removeChild(parent);
                        }

                        setTimeout(function () {
                            wysihtml5.quirks.redraw(element);
                        }, 0);
                    }
                    event.preventDefault();
                }
            }
        });

        // --------- IE 8+9 focus the editor when the iframe is clicked (without actually firing the 'focus' event on the <body>) ---------
        if (browser.hasIframeFocusIssue()) {
            dom.observe(this.container, "focus", function () {
                setTimeout(function () {
                    if (that.doc.querySelector(":focus") !== that.element) {
                        that.focus();
                    }
                }, 0);
            });

            dom.observe(this.element, "blur", function () {
                setTimeout(function () {
                    that.selection.getSelection().removeAllRanges();
                }, 0);
            });
        }

        // --------- Show url in tooltip when hovering links or images ---------
        var titlePrefixes = {
            IMG : "Image: ",
            A : "Link: "
        };

        dom.observe(element, "mouseover", function (event) {
            var target = event.target,
                nodeName = target.nodeName,
                title;
            if (nodeName !== "A" && nodeName !== "IMG") {
                return;
            }
            var hasTitle = target.hasAttribute("title");
            if (!hasTitle) {
                title = titlePrefixes[nodeName] + (target.getAttribute("href") || target.getAttribute("src"));
                target.setAttribute("title", title);
            }
        });
    };
})(wysihtml5);
/**
 * Class that takes care that the value of the composer and the textarea is always in sync
 */
(function (wysihtml5) {
    var INTERVAL = 400;

    wysihtml5.views.Synchronizer = Base.extend(
        /** @scope wysihtml5.views.Synchronizer.prototype */ {

            constructor : function (editor, textarea, composer) {
                this.editor = editor;
                this.textarea = textarea;
                this.composer = composer;

                this._observe();
            },

            /**
             * Sync html from composer to textarea
             * Takes care of placeholders
             * @param {Boolean} shouldParseHtml Whether the html should be sanitized before inserting it into the textarea
             */
            fromComposerToTextarea : function (shouldParseHtml) {
                this.textarea.setValue(wysihtml5.lang.string(this.composer.getValue()).trim(), shouldParseHtml);
            },

            /**
             * Sync value of textarea to composer
             * Takes care of placeholders
             * @param {Boolean} shouldParseHtml Whether the html should be sanitized before inserting it into the composer
             */
            fromTextareaToComposer : function (shouldParseHtml) {
                var textareaValue = this.textarea.getValue();
                if (textareaValue) {
                    this.composer.setValue(textareaValue, shouldParseHtml);
                } else {
                    this.composer.clear();
                    this.editor.fire("set_placeholder");
                }
            },

            /**
             * Invoke syncing based on view state
             * @param {Boolean} shouldParseHtml Whether the html should be sanitized before inserting it into the composer/textarea
             */
            sync : function (shouldParseHtml) {
                if (this.editor.currentView.name === "textarea") {
                    this.fromTextareaToComposer(shouldParseHtml);
                } else {
                    this.fromComposerToTextarea(shouldParseHtml);
                }
            },

            /**
             * Initializes interval-based syncing
             * also makes sure that on-submit the composer's content is synced with the textarea
             * immediately when the form gets submitted
             */
            _observe : function () {
                var interval,
                    that = this,
                    form = this.textarea.element.form,
                    startInterval = function () {
                        interval = setInterval(function () {
                            that.fromComposerToTextarea();
                        }, INTERVAL);
                    },
                    stopInterval = function () {
                        clearInterval(interval);
                        interval = null;
                    };

                startInterval();

                if (form) {
                    // If the textarea is in a form make sure that after onreset and onsubmit the composer
                    // has the correct state
                    wysihtml5.dom.observe(form, "submit", function () {
                        that.sync(true);
                    });
                    wysihtml5.dom.observe(form, "reset", function () {
                        setTimeout(function () {
                            that.fromTextareaToComposer();
                        }, 0);
                    });
                }

                this.editor.on("change_view", function (view) {
                    if (view === "composer" && !interval) {
                        that.fromTextareaToComposer(true);
                        startInterval();
                    } else if (view === "textarea") {
                        that.fromComposerToTextarea(true);
                        stopInterval();
                    }
                });

                this.editor.on("destroy:composer", stopInterval);
            }
        });
})(wysihtml5);
wysihtml5.views.Textarea = wysihtml5.views.View.extend(
    /** @scope wysihtml5.views.Textarea.prototype */ {
        name : "textarea",

        constructor : function (parent, textareaElement, config) {
            this.base(parent, textareaElement, config);

            this._observe();
        },

        clear : function () {
            this.element.value = "";
        },

        getValue : function (parse) {
            var value = this.isEmpty() ? "" : this.element.value;
            if (parse && value) {
                value = this.parent.parse(value);
            }
            return value;
        },

        setValue : function (html, parse) {
            if (parse) {
                html = this.parent.parse(html);
            }
            this.element.value = html;
        },

        hasPlaceholderSet : function () {
            var supportsPlaceholder = wysihtml5.browser.supportsPlaceholderAttributeOn(this.element),
                placeholderText = this.element.getAttribute("placeholder") || null,
                value = this.element.value,
                isEmpty = !value;
            return (supportsPlaceholder && isEmpty) || (value === placeholderText);
        },

        isEmpty : function () {
            return !this.element.value || !wysihtml5.lang.string(this.element.value).trim() || this.hasPlaceholderSet();
        },

        _observe : function () {
            var element = this.element,
                parent = this.parent,
                eventMapping = {
                    focusin : "focus",
                    focusout : "blur"
                },
                /**
                 * Calling focus() or blur() on an element doesn't synchronously trigger the attached focus/blur events
                 * This is the case for focusin and focusout, so let's use them whenever possible, kkthxbai
                 */
                events = wysihtml5.browser.supportsEvent("focusin") ? ["focusin", "focusout", "change"] : ["focus", "blur", "change"];

            parent.on("beforeload", function () {
                wysihtml5.dom.observe(element, events, function (event) {
                    var eventName = eventMapping[event.type] || event.type;
                    parent.fire(eventName).fire(eventName + ":textarea");
                });

                wysihtml5.dom.observe(element, ["paste", "drop"], function () {
                    setTimeout(function () {
                        parent.fire("paste").fire("paste:textarea");
                    }, 0);
                });
            });
        }
    });
/**
 * Toolbar Dialog
 *
 * @param {Element} link The toolbar link which causes the dialog to show up
 * @param {Element} container The dialog container
 *
 * @example
 *    <!-- Toolbar link -->
 *    <a data-wysihtml5-command="insertImage">insert an image</a>
 *
 *    <!-- Dialog -->
 *    <div data-wysihtml5-dialog="insertImage" style="display: none;">
 *      <label>
 *        URL: <input data-wysihtml5-dialog-field="src" value="http://">
 *      </label>
 *      <label>
 *        Alternative text: <input data-wysihtml5-dialog-field="alt" value="">
 *      </label>
 *    </div>
 *
 *    <script>
 *      var dialog = new wysihtml5.toolbar.Dialog(
 *        document.querySelector("[data-wysihtml5-command='insertImage']"),
 *        document.querySelector("[data-wysihtml5-dialog='insertImage']")
 *      );
 *      dialog.observe("save", function(attributes) {
 *        // do something
 *      });
 *    </script>
 */
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        CLASS_NAME_OPENED = "wysihtml5-command-dialog-opened",
        SELECTOR_FORM_ELEMENTS = "input, select, textarea",
        SELECTOR_FIELDS = "[data-wysihtml5-dialog-field]",
        ATTRIBUTE_FIELDS = "data-wysihtml5-dialog-field";

    wysihtml5.toolbar.Dialog = wysihtml5.lang.Dispatcher.extend(
        /** @scope wysihtml5.toolbar.Dialog.prototype */ {
            constructor : function (link, container) {
                this.link = link;
                this.container = container;
            },

            _observe : function () {
                if (this._observed) {
                    return;
                }

                var that = this,
                    callbackWrapper = function (event) {
                        var attributes = that._serialize();
                        if (attributes == that.elementToChange) {
                            that.fire("edit", attributes);
                        } else {
                            that.fire("save", attributes);
                        }
                        that.hide();
                        event.preventDefault();
                        event.stopPropagation();
                    };

                dom.observe(that.link, "click", function () {
                    if (dom.hasClass(that.link, CLASS_NAME_OPENED)) {
                        setTimeout(function () {
                            that.hide();
                        }, 0);
                    }
                });

                dom.observe(this.container, "keydown", function (event) {
                    var keyCode = event.keyCode;
                    if (keyCode === wysihtml5.ENTER_KEY) {
                        callbackWrapper(event);
                    }
                    if (keyCode === wysihtml5.ESCAPE_KEY) {
                        that.hide();
                    }
                });

                dom.delegate(this.container, "[data-wysihtml5-dialog-action=save]", "click", callbackWrapper);

                dom.delegate(this.container, "[data-wysihtml5-dialog-action=cancel]", "click", function (event) {
                    that.fire("cancel");
                    that.hide();
                    event.preventDefault();
                    event.stopPropagation();
                });

                var formElements = this.container.querySelectorAll(SELECTOR_FORM_ELEMENTS),
                    i = 0,
                    length = formElements.length,
                    _clearInterval = function () {
                        clearInterval(that.interval);
                    };
                for (;
                    i < length;
                    i++) {
                    dom.observe(formElements[i], "change", _clearInterval);
                }

                this._observed = true;
            },

            /**
             * Grabs all fields in the dialog and puts them in key=>value style in an object which
             * then gets returned
             */
            _serialize : function () {
                var data = this.elementToChange || {},
                    fields = this.container.querySelectorAll(SELECTOR_FIELDS),
                    length = fields.length,
                    i = 0;
                for (;
                    i < length;
                    i++) {
                    data[fields[i].getAttribute(ATTRIBUTE_FIELDS)] = fields[i].value;
                }
                return data;
            },

            /**
             * Takes the attributes of the "elementToChange"
             * and inserts them in their corresponding dialog input fields
             *
             * Assume the "elementToChange" looks like this:
             *    <a href="http://www.google.com" target="_blank">foo</a>
             *
             * and we have the following dialog:
             *    <input type="text" data-wysihtml5-dialog-field="href" value="">
             *    <input type="text" data-wysihtml5-dialog-field="target" value="">
             *
             * after calling _interpolate() the dialog will look like this
             *    <input type="text" data-wysihtml5-dialog-field="href" value="http://www.google.com">
             *    <input type="text" data-wysihtml5-dialog-field="target" value="_blank">
             *
             * Basically it adopted the attribute values into the corresponding input fields
             *
             */
            _interpolate : function (avoidHiddenFields) {
                var field,
                    fieldName,
                    newValue,
                    focusedElement = document.querySelector(":focus"),
                    fields = this.container.querySelectorAll(SELECTOR_FIELDS),
                    length = fields.length,
                    i = 0;
                for (;
                    i < length;
                    i++) {
                    field = fields[i];

                    // Never change elements where the user is currently typing in
                    if (field === focusedElement) {
                        continue;
                    }

                    // Don't update hidden fields
                    // See https://github.com/xing/wysihtml5/pull/14
                    if (avoidHiddenFields && field.type === "hidden") {
                        continue;
                    }

                    fieldName = field.getAttribute(ATTRIBUTE_FIELDS);
                    newValue = this.elementToChange ? (this.elementToChange[fieldName] || "") : field.defaultValue;
                    field.value = newValue;
                }
            },

            /**
             * Show the dialog element
             */
            show : function (elementToChange) {
                if (dom.hasClass(this.link, CLASS_NAME_OPENED)) {
                    return;
                }

                var that = this,
                    firstField = this.container.querySelector(SELECTOR_FORM_ELEMENTS);
                this.elementToChange = elementToChange;
                this._observe();
                this._interpolate();
                if (elementToChange) {
                    this.interval = setInterval(function () {
                        that._interpolate(true);
                    }, 500);
                }
                dom.addClass(this.link, CLASS_NAME_OPENED);
                this.container.style.display = "";
                this.fire("show");
                if (firstField && !elementToChange) {
                    try {
                        firstField.focus();
                    } catch (e) {
                    }
                }
            },

            /**
             * Hide the dialog element
             */
            hide : function () {
                clearInterval(this.interval);
                this.elementToChange = null;
                dom.removeClass(this.link, CLASS_NAME_OPENED);
                this.container.style.display = "none";
                this.fire("hide");
            }
        });
})(wysihtml5);
/**
 * Converts speech-to-text and inserts this into the editor
 * As of now (2011/03/25) this only is supported in Chrome >= 11
 *
 * Note that it sends the recorded audio to the google speech recognition api:
 * http://stackoverflow.com/questions/4361826/does-chrome-have-buil-in-speech-recognition-for-input-type-text-x-webkit-speec
 *
 * Current HTML5 draft can be found here
 * http://lists.w3.org/Archives/Public/public-xg-htmlspeech/2011Feb/att-0020/api-draft.html
 *
 * "Accessing Google Speech API Chrome 11"
 * http://mikepultz.com/2011/03/accessing-google-speech-api-chrome-11/
 */
(function (wysihtml5) {
    var dom = wysihtml5.dom;

    var linkStyles = {
        position : "relative"
    };

    var wrapperStyles = {
        left : 0,
        margin : 0,
        opacity : 0,
        overflow : "hidden",
        padding : 0,
        position : "absolute",
        top : 0,
        zIndex : 1
    };

    var inputStyles = {
        cursor : "inherit",
        fontSize : "50px",
        height : "50px",
        marginTop : "-25px",
        outline : 0,
        padding : 0,
        position : "absolute",
        right : "-4px",
        top : "50%"
    };

    var inputAttributes = {
        "x-webkit-speech" : "",
        "speech" : ""
    };

    wysihtml5.toolbar.Speech = function (parent, link) {
        var input = document.createElement("input");
        if (!wysihtml5.browser.supportsSpeechApiOn(input)) {
            link.style.display = "none";
            return;
        }
        var lang = parent.editor.textarea.element.getAttribute("lang");
        if (lang) {
            inputAttributes.lang = lang;
        }

        var wrapper = document.createElement("div");

        wysihtml5.lang.object(wrapperStyles).merge({
            width : link.offsetWidth + "px",
            height : link.offsetHeight + "px"
        });

        dom.insert(input).into(wrapper);
        dom.insert(wrapper).into(link);

        dom.setStyles(inputStyles).on(input);
        dom.setAttributes(inputAttributes).on(input);

        dom.setStyles(wrapperStyles).on(wrapper);
        dom.setStyles(linkStyles).on(link);

        var eventName = "onwebkitspeechchange" in input ? "webkitspeechchange" : "speechchange";
        dom.observe(input, eventName, function () {
            parent.execCommand("insertText", input.value);
            input.value = "";
        });

        dom.observe(input, "click", function (event) {
            if (dom.hasClass(link, "wysihtml5-command-disabled")) {
                event.preventDefault();
            }

            event.stopPropagation();
        });
    };
})(wysihtml5);
/**
 * Toolbar
 *
 * @param {Object} parent Reference to instance of Editor instance
 * @param {Element} container Reference to the toolbar container element
 *
 * @example
 *    <div id="toolbar">
 *      <a data-wysihtml5-command="createLink">insert link</a>
 *      <a data-wysihtml5-command="formatBlock" data-wysihtml5-command-value="h1">insert h1</a>
 *    </div>
 *
 *    <script>
 *      var toolbar = new wysihtml5.toolbar.Toolbar(editor, document.getElementById("toolbar"));
 *    </script>
 */
(function (wysihtml5) {
    var CLASS_NAME_COMMAND_DISABLED = "wysihtml5-command-disabled",
        CLASS_NAME_COMMANDS_DISABLED = "wysihtml5-commands-disabled",
        CLASS_NAME_COMMAND_ACTIVE = "wysihtml5-command-active",
        CLASS_NAME_ACTION_ACTIVE = "wysihtml5-action-active",
        dom = wysihtml5.dom;

    wysihtml5.toolbar.Toolbar = Base.extend(
        /** @scope wysihtml5.toolbar.Toolbar.prototype */ {
            constructor : function (editor, container) {
                this.editor = editor;
                this.container = typeof(container) === "string" ? document.getElementById(container) : container;
                this.composer = editor.composer;

                if (!this.container.classList.contains("wysihtml5-toolbar")) {
                    this._getLinks("command");
                    this._getLinks("action");

                    this._observe();
                    this.show();

                    var speechInputLinks = this.container.querySelectorAll("[data-wysihtml5-command=insertSpeech]"),
                        length = speechInputLinks.length,
                        i = 0;
                    for (;
                        i < length;
                        i++) {
                        new wysihtml5.toolbar.Speech(this, speechInputLinks[i]);
                    }
                }
                this.container.classList.add("wysihtml5-toolbar");
            },

            _getLinks : function (type) {
                var links = this[type + "Links"] = wysihtml5.lang.array(this.container.querySelectorAll("[data-wysihtml5-" + type + "]")).get(),
                    length = links.length,
                    i = 0,
                    mapping = this[type + "Mapping"] = {},
                    link,
                    group,
                    name,
                    value,
                    dialog;
                for (;
                    i < length;
                    i++) {
                    link = links[i];
                    name = link.getAttribute("data-wysihtml5-" + type);
                    value = link.getAttribute("data-wysihtml5-" + type + "-value");
                    func = link.getAttribute("data-wysihtml5-" + type + "-stateCallbackFn");
                    elementName = link.getAttribute("data-wysihtml5-" + type + "-element");
                    isDefault = link.getAttribute("data-wysihtml5-" + type + "-default");
                    group = this.container.querySelector("[data-wysihtml5-" + type + "-group='" + name + "']");
                    dialog = this._getDialog(link, name);

                    mapping[name + ":" + value] = {
                        link : link,
                        group : group,
                        name : name,
                        func : func,
                        elementName : elementName,
                        isDefault : isDefault == "" ? true : false,
                        value : value,
                        dialog : dialog,
                        state : false
                    };
                }
            },

            _getDialog : function (link, command) {
                var that = this,
                    dialogElement = this.container.querySelector("[data-wysihtml5-dialog='" + command + "']"),
                    dialog,
                    caretBookmark;

                if (dialogElement) {
                    dialog = new wysihtml5.toolbar.Dialog(link, dialogElement);

                    dialog.on("show", function () {
                        caretBookmark = that.composer.selection.getBookmark();

                        that.editor.fire("show:dialog", {
                            command : command,
                            dialogContainer : dialogElement,
                            commandLink : link
                        });
                    });

                    dialog.on("save", function () {
                        if (caretBookmark) {
                            that.composer.selection.setBookmark(caretBookmark);
                        }
                        that._execCommand(command, attributes);
                        that.editor.fire("save:dialog", {
                            command : command,
                            dialogContainer : dialogElement,
                            commandLink : link
                        });
                    });

                    dialog.on("saveOnly", function () {
                        if (caretBookmark) {
                            that.composer.selection.setBookmark(caretBookmark);
                        }
                    });

                    dialog.on("cancel", function () {
                        that.editor.focus(false);
                        that.editor.fire("cancel:dialog", {
                            command : command,
                            dialogContainer : dialogElement,
                            commandLink : link
                        });
                    });
                }
                return dialog;
            },

            /**
             * @example
             *    var toolbar = new wysihtml5.Toolbar();
             *    // Insert a <blockquote> element or wrap current selection in <blockquote>
             *    toolbar.execCommand("formatBlock", "blockquote");
             */
            execCommand : function (command, commandValue) {
                if (this.commandsDisabled) {
                    return;
                }

                var commandObj = this.commandMapping[command + ":" + commandValue];

                // Show dialog when available
                if (commandObj && commandObj.dialog && !commandObj.state) {
                    commandObj.dialog.show();
                } else {
                    this._execCommand(command, commandValue);
                }
            },

            _execCommand : function (command, commandValue) {

                this.composer.commands.exec(command, commandValue);
                this._updateLinkStates();
            },

            execAction : function (action) {
                var editor = this.editor;
                if (action === "change_view") {
                    if (editor.currentView === editor.textarea) {
                        editor.fire("change_view", "composer");
                    } else {
                        editor.fire("change_view", "textarea");
                    }
                }
            },

            _observe : function () {
                var that = this,
                    editor = this.editor,
                    container = this.container,
                    links = this.commandLinks.concat(this.actionLinks),
                    length = links.length,
                    i = 0;

                for (;
                    i < length;
                    i++) {
                    // 'javascript:;' and unselectable=on Needed for IE, but done in all browsers to make sure that all get the same css applied
                    // (you know, a:link {... } doesn't match anchors with missing href attribute)
                    var attributes = {};
                    attributes.href = "javascript:;";
                    if (links[i] && !links[i].hasAttribute("unselectable") && links[i].tagName.toLowerCase() != "input") {
                        attributes.unselectable = "on";
                    }
                    dom.setAttributes(attributes).on(links[i]);
                }

                // Needed for opera and chrome
                dom.delegate(container, "[data-wysihtml5-action]", "mousedown", function (event) {
                    event.preventDefault();
                });

                dom.delegate(container, "[data-wysihtml5-command]", "mousedown", function (event) {
                    var link = this,
                        command = link.getAttribute("data-wysihtml5-command"),
                        commandValue = link.getAttribute("data-wysihtml5-command-value");

                    //To allow default action in case of margin fields.
                    if (!link.hasAttribute("data-wysihtml5-skip")) {
                        event.preventDefault();
                    }
                });

                dom.delegate(container, "[data-wysihtml5-command]", "click", function (event) {
                    var link = this,
                        command = link.getAttribute("data-wysihtml5-command"),
                        commandValue = link.getAttribute("data-wysihtml5-command-value"),
                        form = link.form;
                    if (commandValue === null && form) {
                        commandValue = {};
                        var formInputs = form.querySelectorAll("input[name], textarea[name]");
                        for (var i = 0; i < formInputs.length; i++) {
                            var element = formInputs[i];
                            var value = element.value;
                            if (element.type === "checkbox") {
                                value = element.checked;
                            }
                            commandValue[element.name] = value;
                        }
                    }

                    if (!link.hasAttribute("data-wysihtml5-skip")) {
                        that.execCommand(command, commandValue);
                        event.preventDefault();
                    }
                });

                dom.delegate(container, "select[data-wysihtml5-command]", "change", function (event) {
                    var link = this,
                        command = link.getAttribute("data-wysihtml5-command"),
                        commandValue = link.value;
                    that.execCommand(command, commandValue);
                    event.preventDefault();
                });

                dom.delegate(container, "input[data-wysihtml5-command]", "change", function (event) {
                    var link = this,
                        command = link.getAttribute("data-wysihtml5-command"),
                        commandValue = link.type === "checkbox" ? link.checked : link.value;
                    that.execCommand(command, commandValue);
                    event.preventDefault();
                });

                dom.delegate(container, "[data-wysihtml5-action]", "click", function (event) {
                    var action = this.getAttribute("data-wysihtml5-action");
                    that.execAction(action);
                    event.preventDefault();
                });

                editor.on("focus:composer", function () {
                    that.bookmark = null;
                    clearInterval(that.interval);
                    that.interval = setInterval(function () {
                        that._updateLinkStates();
                    }, 500);
                });

                editor.on("blur:composer", function () {
                    clearInterval(that.interval);
                });

                editor.on("destroy:composer", function () {
                    clearInterval(that.interval);
                });

                editor.on("change_view", function (currentView) {
                    // Set timeout needed in order to let the blur event fire first
                    setTimeout(function () {
                        that.commandsDisabled = (currentView !== "composer");
                        that._updateLinkStates();
                        if (that.commandsDisabled) {
                            dom.addClass(container, CLASS_NAME_COMMANDS_DISABLED);
                        } else {
                            dom.removeClass(container, CLASS_NAME_COMMANDS_DISABLED);
                        }
                    }, 0);
                });
            },

            _updateLinkStates : function () {
                var commandMapping = this.commandMapping,
                    actionMapping = this.actionMapping,
                    i,
                    state,
                    action,
                    command;
                // every millisecond counts... this is executed quite often

                for (i in commandMapping) {
                    command = commandMapping[i];
                    if (!this.commandsDisabled) {
                        var func = wysihtml5.util.getObjectProperty(window, command.func);
                        if (func) {
                            state = this.composer.commands.callbackState(command.name, command.value, command.isDefault);
                            if (wysihtml5.lang.object(state).isArray()) {
                                // Grab first and only object/element in state array, otherwise convert state into boolean
                                // to avoid showing a dialog for multiple selected elements which may have different attributes
                                // eg. when two links with different href are selected, the state will be an array consisting of both link elements
                                // but the dialog interface can only update one
                                state = state.length === 1 ? state[0] : true;
                            }
                            dom.removeClass(command.link, CLASS_NAME_COMMAND_DISABLED);
                            if (command.group) {
                                dom.removeClass(command.group, CLASS_NAME_COMMAND_DISABLED);
                            }
                            func(command.link, state, command.elementName, command.name, command.value, command.isDefault);
                        }
                    }
                }

                for (i in actionMapping) {
                    action = actionMapping[i];
                    if (action.name === "change_view") {
                        action.state = this.editor.currentView === this.editor.textarea;
                        if (action.state) {
                            dom.addClass(action.link, CLASS_NAME_ACTION_ACTIVE);
                        } else {
                            dom.removeClass(action.link, CLASS_NAME_ACTION_ACTIVE);
                        }
                    }
                }
            },

            show : function () {
                this.container.style.display = "";
            },

            hide : function () {
                this.container.style.display = "none";
            }
        });
})(wysihtml5);
/**
 * WYSIHTML5 Editor
 *
 * @param {Element} textareaElement Reference to the textarea which should be turned into a rich text interface
 * @param {Object} [config] See defaultConfig object below for explanation of each individual config option
 *
 * @events
 *    load
 *    beforeload (for internal use only)
 *    focus
 *    focus:composer
 *    click:composer
 *    focus:textarea
 *    blur
 *    blur:composer
 *    blur:textarea
 *    change
 *    change:composer
 *    change:textarea
 *    paste
 *    paste:composer
 *    paste:textarea
 *    newword:composer
 *    destroy:composer
 *    undo:composer
 *    redo:composer
 *    beforecommand:composer
 *    aftercommand:composer
 *    enable:composer
 *    disable:composer
 *    change_view
 */
(function (wysihtml5) {
    var undef;

    var defaultConfig = {
        // Give the editor a name, the name will also be set as class name on the iframe and on the iframe's body
        name : undef,
        // Whether the editor should look like the textarea (by adopting styles)
        style : true,
        // Id of the toolbar element, pass falsey value if you don't want any toolbar logic
        toolbar : undef,
        // Whether urls, entered by the user should automatically become clickable-links
        autoLink : true,
        // Object which includes parser rules to apply when html gets inserted via copy & paste
        // See parser_rules/*.js for examples
        parserRules : {tags : {br : {}, span : {}, div : {}, p : {}}, classes : {}},
        // Parser method to use when the user inserts content via copy & paste
        parser : wysihtml5.dom.parse,
        // Class name which should be set on the contentEditable element in the created sandbox iframe, can be styled via the 'stylesheets' option
        composerClassName : "wysihtml5-editor",
        // Class name to add to the body when the wysihtml5 editor is supported
        bodyClassName : "wysihtml5-supported",
        // By default wysihtml5 will insert a <br> for line breaks, set this to false to use <p>
        useLineBreaks : true,
        pasteAsPlainText : false,
        // Array (or single string) of stylesheet urls to be loaded in the editor's iframe
        stylesheets : [],
        // Placeholder text to use, defaults to the placeholder attribute on the textarea element
        placeholderText : undef,
        // Whether the rich text editor should be rendered on touch devices (wysihtml5 >= 0.3.0 comes with basic support for iOS 5)
        supportTouchDevices : true
    };

    wysihtml5.Editor = wysihtml5.lang.Dispatcher.extend(
        /** @scope wysihtml5.Editor.prototype */ {
            constructor : function (textareaElement, config) {
                this.textareaElement = typeof(textareaElement) === "string" ? document.getElementById(textareaElement) : textareaElement;
                this.config = wysihtml5.lang.object({}).merge(defaultConfig).merge(config).get();
                this.textarea = new wysihtml5.views.Textarea(this, this.textareaElement, this.config);
                this.currentView = this.textarea;
                this._isCompatible = wysihtml5.browser.supported();

                // Sort out unsupported/unwanted browsers here
                if (!this._isCompatible || (!this.config.supportTouchDevices && wysihtml5.browser.isTouchDevice())) {
                    var that = this;
                    setTimeout(function () {
                        that.fire("beforeload").fire("load");
                    }, 0);
                    return;
                }

                // Add class name to body, to indicate that the editor is supported
                wysihtml5.dom.addClass(document.body, this.config.bodyClassName);

                this.composer = new wysihtml5.views.Composer(this, this.textareaElement, this.config);
                this.currentView = this.composer;

                if (typeof(this.config.parser) === "function") {
                    this._initParser();
                }

                if (this.config.parserRules) {
                    this.parserRules = this.config.parserRules;
                }

                this.on("beforeload", function () {
                    this.synchronizer = new wysihtml5.views.Synchronizer(this, this.textarea, this.composer);
                    if (this.config.toolbar) {
                        this.toolbar = new wysihtml5.toolbar.Toolbar(this, this.config.toolbar);
                    }
                });
                this.composer._create();
                try {
                    console.log("Heya! This page is using wysihtml5 for rich text editing. Check out https://github.com/xing/wysihtml5");
                } catch (e) {
                }
            },

            setToolbar : function (toolbar) {
                this.toolbar = new wysihtml5.toolbar.Toolbar(this, toolbar);
            },

            isCompatible : function () {
                return this._isCompatible;
            },

            clear : function () {
                this.currentView.clear();
                return this;
            },

            getValue : function (parse) {
                return this.currentView.getValue(parse);
            },

            setValue : function (html, parse) {
                this.fire("unset_placeholder");

                if (!html) {
                    return this.clear();
                }

                this.currentView.setValue(html, parse);
                return this;
            },

            focus : function (setToEnd) {
                this.currentView.focus(setToEnd);
                return this;
            },

            /**
             * Deactivate editor (make it readonly)
             */
            disable : function () {
                this.currentView.disable();
                return this;
            },

            /**
             * Activate editor
             */
            enable : function () {
                this.currentView.enable();
                return this;
            },

            isEmpty : function () {
                return this.currentView.isEmpty();
            },

            hasPlaceholderSet : function () {
                return this.currentView.hasPlaceholderSet();
            },

            parse : function (htmlOrElement, preProcess) {
                var returnValue = this.config.parser(htmlOrElement, this.config.parserRules, this.composer.sandbox.getDocument(), true, preProcess);
                if (typeof(htmlOrElement) === "object") {
                    wysihtml5.quirks.redraw(htmlOrElement);
                }
                return returnValue;
            },

            /**
             * Prepare html parser logic
             *  - Observes for paste and drop
             */
            _initParser : function () {
                this.on("paste:composer", function () {
                    var keepScrollPosition = true,
                        that = this;
                    that.composer.selection.executeAndRestore(function () {
                        wysihtml5.quirks.cleanPastedHTML(that.composer.element);
                        that.parse(that.composer.element);
                    }, keepScrollPosition);
                });
            }
        });
})(wysihtml5);

/**
 * These rules define which tags and css classes are supported and which tags should be specially treated.
 *
 * Examples based on this rule set:
 *
 *    <a href="http://foobar.com">foo</a>
 *    ... becomes ...
 *    <a href="http://foobar.com" target="_blank" rel="nofollow">foo</a>
 *
 *    <img align="left" src="http://foobar.com/image.png">
 *    ... becomes ...
 *    <img class="wysiwyg-float-left" src="http://foobar.com/image.png" alt="">
 *
 *    <div>foo<script>alert(document.cookie)</script></div>
 *    ... becomes ...
 *    <div>foo</div>
 *
 *    <marquee>foo</marquee>
 *    ... becomes ...
 *    <span>foo</marquee>
 *
 *    foo <br clear="both"> bar
 *    ... becomes ...
 *    foo <br class="wysiwyg-clear-both"> bar
 *
 *    <div>hello <iframe src="http://google.com"></iframe></div>
 *    ... becomes ...
 *    <div>hello </div>
 *
 *    <center>hello</center>
 *    ... becomes ...
 *    <div class="wysiwyg-text-align-center">hello</div>
 */
var wysihtml5SupportedParserRules = {
    /**
     * CSS Class white-list
     * Following css classes won't be removed when parsed by the wysihtml5 html parser
     */
    "classes" : {
        "textEditor-customDataAttr" : 1
    },
    /**
     * Tag list
     *
     * Following options are available:
     *
     *    - add_class:        converts and deletes the given HTML4 attribute (align, clear, ...) via the given method to a css class
     *                        The following methods are implemented in wysihtml5.dom.parse:
     *                          - align_text:  converts align attribute values (right/left/center/justify) to their corresponding css class "wysiwyg-text-align-*")
     <p align="center">foo</p> ... becomes ... <p> class="wysiwyg-text-align-center">foo</p>
     *                          - clear_br:    converts clear attribute values left/right/all/both to their corresponding css class "wysiwyg-clear-*"
     *                            <br clear="all"> ... becomes ... <br class="wysiwyg-clear-both">
     *                          - align_img:    converts align attribute values (right/left) on <img> to their corresponding css class "wysiwyg-float-*"
     *
     *    - remove:             removes the element and it's content
     *
     *    - rename_tag:         renames the element to the given tag
     *
     *    - set_class:          adds the given class to the element (note: make sure that the class is in the "classes" white list above)
     *
     *    - set_attributes:     sets/overrides the given attributes
     *
     *    - remove_attributes:  remove_attributes:  remove given attributes. [attr, property, endString] -> remove attribute property if it ends with endString.
     *
     *    - check_attributes:   checks the given HTML attribute via the given method
     *                            - url:      checks whether the given string is an url, deletes the attribute if not
     *                            - alt:      strips unwanted characters. if the attribute is not set, then it gets set (to ensure valid and compatible HTML)
     *                            - numbers:  ensures that the attribute only contains numeric characters
     */
    "tags" : {
        "ul" : {},
        "ol" : {},
        "li" : {},
        "b" : {},
        "i" : {},
        "u" : {},
        "sup" : {},
        "sub" : {},
        "br" : {
            "remove_attributes" : ["style"]
        },
        "h1" : {},
        "h2" : {},
        "h3" : {},
        "h4" : {},
        "h5" : {},
        "h6" : {},
        "a" : {
            "check_attributes" : {
                "href" : "url"
            },
            "set_attributes" : {
                "rel" : "nofollow",
                "target" : "_blank"
            },
            "remove_attributes" : ["style,background-color"]
        },
        "q" : {
            "check_attributes" : {
                "cite" : "url"
            }
        },
        "hr" : {},
        "pre" : {},
        "span" : {
            "remove_attributes" : ["style,line-height", "style,text-align", "style,margin-left", "style,margin-right", "style,margin-top", "style,margin-bottom", "style,margin"]
        },
        "p" : {},
        "table" : {
            "check_attributes" : {
                "cellpadding" : "any",
                "cellspacing" : "any",
                "border" : "any",
                "width" : "any",
                "height" : "any"
            }
        },
        "thead" : {},
        "tfoot" : {},
        "th" : {},
        "col" : {
            "check_attributes" : {
                "span" : "numbers"
            }
        },
        "tbody" : {},
        "tr" : {},
        "td" : {},
        "form" : {
            "remove" : 1
        },
        "code" : {
            "remove" : 1
        },
        "title" : {
            "remove" : 1
        },
        "area" : {
            "remove" : 1
        },
        "command" : {
            "remove" : 1
        },
        "iframe" : {
            "remove" : 1
        },
        "img" : {
            "remove" : 1
        },
        "noframes" : {
            "remove" : 1
        },
        "bgsound" : {
            "remove" : 1
        },
        "basefont" : {
            "remove" : 1
        },
        "base" : {
            "remove" : 1
        },
        "video" : {
            "remove" : 1
        },
        "canvas" : {
            "remove" : 1
        },
        "applet" : {
            "remove" : 1
        },
        "spacer" : {
            "remove" : 1
        },
        "source" : {
            "remove" : 1
        },
        "frame" : {
            "remove" : 1
        },
        "style" : {
            "remove" : 1
        },
        "device" : {
            "remove" : 1
        },
        "embed" : {
            "remove" : 1
        },
        "noembed" : {
            "remove" : 1
        },
        "xml" : {
            "remove" : 1
        },
        "param" : {
            "remove" : 1
        },
        "audio" : {
            "remove" : 1
        },
        "nextid" : {
            "remove" : 1
        },
        "link" : {
            "remove" : 1
        },
        "script" : {
            "remove" : 1
        },
        "colgroup" : {},
        "o:p" : {
            "remove" : 1
        },
        "comment" : {
            "remove" : 1
        },
        "frameset" : {
            "remove" : 1
        },
        "head" : {
            "remove" : 1
        },
        "object" : {
            "remove" : 1
        },
        "track" : {
            "remove" : 1
        },
        "wbr" : {
            "remove" : 1
        },
        "button" : {
            "remove" : 1
        },
        "noscript" : {
            "remove" : 1
        },
        "svg" : {
            "remove" : 1
        },
        "input" : {
            "remove" : 1
        },
        "keygen" : {
            "remove" : 1
        },
        "meta" : {
            "remove" : 1
        },
        "isindex" : {
            "remove" : 1
        },
        "del" : {
            "remove" : 1
        },
        "map" : {
            "remove" : 1
        },
        "address" : {
            "rename_tag" : "p"
        },
        "nav" : {
            "rename_tag" : "p"
        },
        "multicol" : {
            "rename_tag" : "p"
        },
        "figure" : {
            "rename_tag" : "p"
        },
        "figcaption" : {
            "rename_tag" : "p"
        },
        "footer" : {
            "rename_tag" : "p"
        },
        "fieldset" : {
            "rename_tag" : "p"
        },
        "div" : {
            "rename_tag" : "span"
        },
        "aside" : {
            "rename_tag" : "p"
        },
        "section" : {
            "rename_tag" : "p"
        },
        "body" : {
            "rename_tag" : "p"
        },
        "html" : {
            "rename_tag" : "p"
        },
        "hgroup" : {
            "rename_tag" : "p"
        },
        "center" : {
            "rename_tag" : "p"
        },
        "article" : {
            "rename_tag" : "p"
        },
        "header" : {
            "rename_tag" : "p"
        },
        "dl" : {
            "rename_tag" : "p"
        },
        "dd" : {
            "rename_tag" : "span"
        },
        "dt" : {
            "rename_tag" : "span"
        },
        "xmp" : {
            "rename_tag" : "span"
        },
        "small" : {
            "rename_tag" : "span"
        },
        "time" : {
            "rename_tag" : "span"
        },
        "ruby" : {
            "rename_tag" : "span"
        },
        "rt" : {
            "rename_tag" : "span"
        },
        "rp" : {
            "rename_tag" : "span"
        },
        "rb" : {
            "rename_tag" : "span"
        },
        "acronym" : {
            "rename_tag" : "span"
        },
        "details" : {
            "rename_tag" : "span"
        },
        "summary" : {
            "rename_tag" : "span"
        },
        "bdi" : {
            "rename_tag" : "span"
        },
        "progress" : {
            "rename_tag" : "span"
        },
        "dfn" : {
            "rename_tag" : "span"
        },
        "abbr" : {
            "rename_tag" : "span"
        },
        "s" : {
            "rename_tag" : "span"
        },
        "strike" : {
            "rename_tag" : "span"
        },
        "option" : {
            "rename_tag" : "span"
        },
        "optgroup" : {
            "rename_tag" : "span"
        },
        "select" : {
            "rename_tag" : "span"
        },
        "big" : {
            "rename_tag" : "span"
        },
        "mark" : {
            "rename_tag" : "span"
        },
        "caption" : {
            "rename_tag" : "span"
        },
        "output" : {
            "rename_tag" : "span"
        },
        "marquee" : {
            "rename_tag" : "span"
        },
        "nobr" : {
            "rename_tag" : "span"
        },
        "var" : {
            "rename_tag" : "span"
        },
        "meter" : {
            "rename_tag" : "span"
        },
        "blockquote" : {
            "rename_tag" : "span"
        },
        "textarea" : {
            "rename_tag" : "span"
        },
        "font" : {
            "rename_tag" : "span"
        },
        "tt" : {
            "rename_tag" : "span"
        },
        "blink" : {
            "rename_tag" : "span"
        },
        "plaintext" : {
            "rename_tag" : "span"
        },
        "legend" : {
            "rename_tag" : "span"
        },
        "label" : {
            "rename_tag" : "span"
        },
        "kbd" : {
            "rename_tag" : "span"
        },
        "datalist" : {
            "rename_tag" : "span"
        },
        "samp" : {
            "rename_tag" : "span"
        },
        "bdo" : {
            "rename_tag" : "span"
        },
        "ins" : {
            "rename_tag" : "span"
        },
        "strong" : {
            "rename_tag" : "b"
        },
        "em" : {
            "rename_tag" : "i"
        },
        "cite" : {
            "rename_tag" : "i"
        },
        "dir" : {
            "rename_tag" : "ul"
        },
        "menu" : {
            "rename_tag" : "ul"
        },
        "menuitem" : {
            "rename_tag" : "li"
        }
    },
    /**
     * CSS styles white-list
     * Following css styles won't be removed when parsed by the wysihtml5 html parser
     */
    "styles" : [
                "font-family",
                "font-size",
                "color",
                "background-color",
                "letter-spacing",
                "line-height",
                "text-align",
                "margin-left",
                "margin-right",
                "margin-top",
                "margin-bottom",
                "list-style-type",
                "white-space",
                "border-collapse"
                ]
};

/*!

 handlebars v4.0.5

 Copyright (C) 2011-2015 by Yehuda Katz

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.

 @license
 */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["Handlebars"] = factory();
	else
		root["Handlebars"] = factory();
})(this, function() {
	return /******/ (function(modules) { // webpackBootstrap
		/******/ 	// The module cache
		/******/ 	var installedModules = {};

		/******/ 	// The require function
		/******/ 	function __webpack_require__(moduleId) {

			/******/ 		// Check if module is in cache
			/******/ 		if(installedModules[moduleId])
			/******/ 			return installedModules[moduleId].exports;

			/******/ 		// Create a new module (and put it into the cache)
			/******/ 		var module = installedModules[moduleId] = {
				/******/ 			exports: {},
				/******/ 			id: moduleId,
				/******/ 			loaded: false
				/******/ 		};

			/******/ 		// Execute the module function
			/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

			/******/ 		// Flag the module as loaded
			/******/ 		module.loaded = true;

			/******/ 		// Return the exports of the module
			/******/ 		return module.exports;
			/******/ 	}


		/******/ 	// expose the modules object (__webpack_modules__)
		/******/ 	__webpack_require__.m = modules;

		/******/ 	// expose the module cache
		/******/ 	__webpack_require__.c = installedModules;

		/******/ 	// __webpack_public_path__
		/******/ 	__webpack_require__.p = "";

		/******/ 	// Load entry module and return exports
		/******/ 	return __webpack_require__(0);
		/******/ })
		/************************************************************************/
		/******/ ([
		/* 0 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireWildcard = __webpack_require__(1)['default'];

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;

			var _handlebarsBase = __webpack_require__(3);

			var base = _interopRequireWildcard(_handlebarsBase);

			// Each of these augment the Handlebars object. No need to setup here.
			// (This is done to easily share code between commonjs and browse envs)

			var _handlebarsSafeString = __webpack_require__(17);

			var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString);

			var _handlebarsException = __webpack_require__(5);

			var _handlebarsException2 = _interopRequireDefault(_handlebarsException);

			var _handlebarsUtils = __webpack_require__(4);

			var Utils = _interopRequireWildcard(_handlebarsUtils);

			var _handlebarsRuntime = __webpack_require__(18);

			var runtime = _interopRequireWildcard(_handlebarsRuntime);

			var _handlebarsNoConflict = __webpack_require__(19);

			var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict);

			// For compatibility and usage outside of module systems, make the Handlebars object a namespace
			function create() {
				var hb = new base.HandlebarsEnvironment();

				Utils.extend(hb, base);
				hb.SafeString = _handlebarsSafeString2['default'];
				hb.Exception = _handlebarsException2['default'];
				hb.Utils = Utils;
				hb.escapeExpression = Utils.escapeExpression;

				hb.VM = runtime;
				hb.template = function (spec) {
					return runtime.template(spec, hb);
				};

				return hb;
			}

			var inst = create();
			inst.create = create;

			_handlebarsNoConflict2['default'](inst);

			inst['default'] = inst;

			exports['default'] = inst;
			module.exports = exports['default'];

			/***/ },
		/* 1 */
		/***/ function(module, exports) {

			"use strict";

			exports["default"] = function (obj) {
				if (obj && obj.__esModule) {
					return obj;
				} else {
					var newObj = {};

					if (obj != null) {
						for (var key in obj) {
							if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
						}
					}

					newObj["default"] = obj;
					return newObj;
				}
			};

			exports.__esModule = true;

			/***/ },
		/* 2 */
		/***/ function(module, exports) {

			"use strict";

			exports["default"] = function (obj) {
				return obj && obj.__esModule ? obj : {
					"default": obj
				};
			};

			exports.__esModule = true;

			/***/ },
		/* 3 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;
			exports.HandlebarsEnvironment = HandlebarsEnvironment;

			var _utils = __webpack_require__(4);

			var _exception = __webpack_require__(5);

			var _exception2 = _interopRequireDefault(_exception);

			var _helpers = __webpack_require__(6);

			var _decorators = __webpack_require__(14);

			var _logger = __webpack_require__(16);

			var _logger2 = _interopRequireDefault(_logger);

			var VERSION = '4.0.5';
			exports.VERSION = VERSION;
			var COMPILER_REVISION = 7;

			exports.COMPILER_REVISION = COMPILER_REVISION;
			var REVISION_CHANGES = {
				1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
				2: '== 1.0.0-rc.3',
				3: '== 1.0.0-rc.4',
				4: '== 1.x.x',
				5: '== 2.0.0-alpha.x',
				6: '>= 2.0.0-beta.1',
				7: '>= 4.0.0'
			};

			exports.REVISION_CHANGES = REVISION_CHANGES;
			var objectType = '[object Object]';

			function HandlebarsEnvironment(helpers, partials, decorators) {
				this.helpers = helpers || {};
				this.partials = partials || {};
				this.decorators = decorators || {};

				_helpers.registerDefaultHelpers(this);
				_decorators.registerDefaultDecorators(this);
			}

			HandlebarsEnvironment.prototype = {
				constructor: HandlebarsEnvironment,

				logger: _logger2['default'],
				log: _logger2['default'].log,

				registerHelper: function registerHelper(name, fn) {
					if (_utils.toString.call(name) === objectType) {
						if (fn) {
							throw new _exception2['default']('Arg not supported with multiple helpers');
						}
						_utils.extend(this.helpers, name);
					} else {
						this.helpers[name] = fn;
					}
				},
				unregisterHelper: function unregisterHelper(name) {
					delete this.helpers[name];
				},

				registerPartial: function registerPartial(name, partial) {
					if (_utils.toString.call(name) === objectType) {
						_utils.extend(this.partials, name);
					} else {
						if (typeof partial === 'undefined') {
							throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined');
						}
						this.partials[name] = partial;
					}
				},
				unregisterPartial: function unregisterPartial(name) {
					delete this.partials[name];
				},

				registerDecorator: function registerDecorator(name, fn) {
					if (_utils.toString.call(name) === objectType) {
						if (fn) {
							throw new _exception2['default']('Arg not supported with multiple decorators');
						}
						_utils.extend(this.decorators, name);
					} else {
						this.decorators[name] = fn;
					}
				},
				unregisterDecorator: function unregisterDecorator(name) {
					delete this.decorators[name];
				}
			};

			var log = _logger2['default'].log;

			exports.log = log;
			exports.createFrame = _utils.createFrame;
			exports.logger = _logger2['default'];

			/***/ },
		/* 4 */
		/***/ function(module, exports) {

			'use strict';

			exports.__esModule = true;
			exports.extend = extend;
			exports.indexOf = indexOf;
			exports.escapeExpression = escapeExpression;
			exports.isEmpty = isEmpty;
			exports.createFrame = createFrame;
			exports.blockParams = blockParams;
			exports.appendContextPath = appendContextPath;
			var escape = {
				'&': '&amp;',
				'<': '&lt;',
				'>': '&gt;',
				'"': '&quot;',
				"'": '&#x27;',
				'`': '&#x60;',
				'=': '&#x3D;'
			};

			var badChars = /[&<>"'`=]/g,
				possible = /[&<>"'`=]/;

			function escapeChar(chr) {
				return escape[chr];
			}

			function extend(obj /* , ...source */) {
				for (var i = 1; i < arguments.length; i++) {
					for (var key in arguments[i]) {
						if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
							obj[key] = arguments[i][key];
						}
					}
				}

				return obj;
			}

			var toString = Object.prototype.toString;

			exports.toString = toString;
			// Sourced from lodash
			// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
			/* eslint-disable func-style */
			var isFunction = function isFunction(value) {
				return typeof value === 'function';
			};
			// fallback for older versions of Chrome and Safari
			/* istanbul ignore next */
			if (isFunction(/x/)) {
				exports.isFunction = isFunction = function (value) {
					return typeof value === 'function' && toString.call(value) === '[object Function]';
				};
			}
			exports.isFunction = isFunction;

			/* eslint-enable func-style */

			/* istanbul ignore next */
			var isArray = Array.isArray || function (value) {
				return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
			};

			exports.isArray = isArray;
			// Older IE versions do not directly support indexOf so we must implement our own, sadly.

			function indexOf(array, value) {
				for (var i = 0, len = array.length; i < len; i++) {
					if (array[i] === value) {
						return i;
					}
				}
				return -1;
			}

			function escapeExpression(string) {
				if (typeof string !== 'string') {
					// don't escape SafeStrings, since they're already safe
					if (string && string.toHTML) {
						return string.toHTML();
					} else if (string == null) {
						return '';
					} else if (!string) {
						return string + '';
					}

					// Force a string conversion as this will be done by the append regardless and
					// the regex test will do this transparently behind the scenes, causing issues if
					// an object's to string has escaped characters in it.
					string = '' + string;
				}

				if (!possible.test(string)) {
					return string;
				}
				return string.replace(badChars, escapeChar);
			}

			function isEmpty(value) {
				if (!value && value !== 0) {
					return true;
				} else if (isArray(value) && value.length === 0) {
					return true;
				} else {
					return false;
				}
			}

			function createFrame(object) {
				var frame = extend({}, object);
				frame._parent = object;
				return frame;
			}

			function blockParams(params, ids) {
				params.path = ids;
				return params;
			}

			function appendContextPath(contextPath, id) {
				return (contextPath ? contextPath + '.' : '') + id;
			}

			/***/ },
		/* 5 */
		/***/ function(module, exports) {

			'use strict';

			exports.__esModule = true;

			var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];

			function Exception(message, node) {
				var loc = node && node.loc,
					line = undefined,
					column = undefined;
				if (loc) {
					line = loc.start.line;
					column = loc.start.column;

					message += ' - ' + line + ':' + column;
				}

				var tmp = Error.prototype.constructor.call(this, message);

				// Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
				for (var idx = 0; idx < errorProps.length; idx++) {
					this[errorProps[idx]] = tmp[errorProps[idx]];
				}

				/* istanbul ignore else */
				if (Error.captureStackTrace) {
					Error.captureStackTrace(this, Exception);
				}

				if (loc) {
					this.lineNumber = line;
					this.column = column;
				}
			}

			Exception.prototype = new Error();

			exports['default'] = Exception;
			module.exports = exports['default'];

			/***/ },
		/* 6 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;
			exports.registerDefaultHelpers = registerDefaultHelpers;

			var _helpersBlockHelperMissing = __webpack_require__(7);

			var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing);

			var _helpersEach = __webpack_require__(8);

			var _helpersEach2 = _interopRequireDefault(_helpersEach);

			var _helpersHelperMissing = __webpack_require__(9);

			var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing);

			var _helpersIf = __webpack_require__(10);

			var _helpersIf2 = _interopRequireDefault(_helpersIf);

			var _helpersLog = __webpack_require__(11);

			var _helpersLog2 = _interopRequireDefault(_helpersLog);

			var _helpersLookup = __webpack_require__(12);

			var _helpersLookup2 = _interopRequireDefault(_helpersLookup);

			var _helpersWith = __webpack_require__(13);

			var _helpersWith2 = _interopRequireDefault(_helpersWith);

			function registerDefaultHelpers(instance) {
				_helpersBlockHelperMissing2['default'](instance);
				_helpersEach2['default'](instance);
				_helpersHelperMissing2['default'](instance);
				_helpersIf2['default'](instance);
				_helpersLog2['default'](instance);
				_helpersLookup2['default'](instance);
				_helpersWith2['default'](instance);
			}

			/***/ },
		/* 7 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			exports['default'] = function (instance) {
				instance.registerHelper('blockHelperMissing', function (context, options) {
					var inverse = options.inverse,
						fn = options.fn;

					if (context === true) {
						return fn(this);
					} else if (context === false || context == null) {
						return inverse(this);
					} else if (_utils.isArray(context)) {
						if (context.length > 0) {
							if (options.ids) {
								options.ids = [options.name];
							}

							return instance.helpers.each(context, options);
						} else {
							return inverse(this);
						}
					} else {
						if (options.data && options.ids) {
							var data = _utils.createFrame(options.data);
							data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
							options = { data: data };
						}

						return fn(context, options);
					}
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 8 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			var _exception = __webpack_require__(5);

			var _exception2 = _interopRequireDefault(_exception);

			exports['default'] = function (instance) {
				instance.registerHelper('each', function (context, options) {
					if (!options) {
						throw new _exception2['default']('Must pass iterator to #each');
					}

					var fn = options.fn,
						inverse = options.inverse,
						i = 0,
						ret = '',
						data = undefined,
						contextPath = undefined;

					if (options.data && options.ids) {
						contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
					}

					if (_utils.isFunction(context)) {
						context = context.call(this);
					}

					if (options.data) {
						data = _utils.createFrame(options.data);
					}

					function execIteration(field, index, last) {
						if (data) {
							data.key = field;
							data.index = index;
							data.first = index === 0;
							data.last = !!last;

							if (contextPath) {
								data.contextPath = contextPath + field;
							}
						}

						ret = ret + fn(context[field], {
							data: data,
							blockParams: _utils.blockParams([context[field], field], [contextPath + field, null])
						});
					}

					if (context && typeof context === 'object') {
						if (_utils.isArray(context)) {
							for (var j = context.length; i < j; i++) {
								if (i in context) {
									execIteration(i, i, i === context.length - 1);
								}
							}
						} else {
							var priorKey = undefined;

							for (var key in context) {
								if (context.hasOwnProperty(key)) {
									// We're running the iterations one step out of sync so we can detect
									// the last iteration without have to scan the object twice and create
									// an itermediate keys array.
									if (priorKey !== undefined) {
										execIteration(priorKey, i - 1);
									}
									priorKey = key;
									i++;
								}
							}
							if (priorKey !== undefined) {
								execIteration(priorKey, i - 1, true);
							}
						}
					}

					if (i === 0) {
						ret = inverse(this);
					}

					return ret;
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 9 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;

			var _exception = __webpack_require__(5);

			var _exception2 = _interopRequireDefault(_exception);

			exports['default'] = function (instance) {
				instance.registerHelper('helperMissing', function () /* [args, ]options */{
					if (arguments.length === 1) {
						// A missing field in a {{foo}} construct.
						return undefined;
					} else {
						// Someone is actually trying to call something, blow up.
						throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
					}
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 10 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			exports['default'] = function (instance) {
				instance.registerHelper('if', function (conditional, options) {
					if (_utils.isFunction(conditional)) {
						conditional = conditional.call(this);
					}

					// Default behavior is to render the positive path if the value is truthy and not empty.
					// The `includeZero` option may be set to treat the condtional as purely not empty based on the
					// behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
					if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) {
						return options.inverse(this);
					} else {
						return options.fn(this);
					}
				});

				instance.registerHelper('unless', function (conditional, options) {
					return instance.helpers['if'].call(this, conditional, { fn: options.inverse, inverse: options.fn, hash: options.hash });
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 11 */
		/***/ function(module, exports) {

			'use strict';

			exports.__esModule = true;

			exports['default'] = function (instance) {
				instance.registerHelper('log', function () /* message, options */{
					var args = [undefined],
						options = arguments[arguments.length - 1];
					for (var i = 0; i < arguments.length - 1; i++) {
						args.push(arguments[i]);
					}

					var level = 1;
					if (options.hash.level != null) {
						level = options.hash.level;
					} else if (options.data && options.data.level != null) {
						level = options.data.level;
					}
					args[0] = level;

					instance.log.apply(instance, args);
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 12 */
		/***/ function(module, exports) {

			'use strict';

			exports.__esModule = true;

			exports['default'] = function (instance) {
				instance.registerHelper('lookup', function (obj, field) {
					return obj && obj[field];
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 13 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			exports['default'] = function (instance) {
				instance.registerHelper('with', function (context, options) {
					if (_utils.isFunction(context)) {
						context = context.call(this);
					}

					var fn = options.fn;

					if (!_utils.isEmpty(context)) {
						var data = options.data;
						if (options.data && options.ids) {
							data = _utils.createFrame(options.data);
							data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);
						}

						return fn(context, {
							data: data,
							blockParams: _utils.blockParams([context], [data && data.contextPath])
						});
					} else {
						return options.inverse(this);
					}
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 14 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;
			exports.registerDefaultDecorators = registerDefaultDecorators;

			var _decoratorsInline = __webpack_require__(15);

			var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline);

			function registerDefaultDecorators(instance) {
				_decoratorsInline2['default'](instance);
			}

			/***/ },
		/* 15 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			exports['default'] = function (instance) {
				instance.registerDecorator('inline', function (fn, props, container, options) {
					var ret = fn;
					if (!props.partials) {
						props.partials = {};
						ret = function (context, options) {
							// Create a new partials stack frame prior to exec.
							var original = container.partials;
							container.partials = _utils.extend({}, original, props.partials);
							var ret = fn(context, options);
							container.partials = original;
							return ret;
						};
					}

					props.partials[options.args[0]] = options.fn;

					return ret;
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 16 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			var logger = {
				methodMap: ['debug', 'info', 'warn', 'error'],
				level: 'info',

				// Maps a given level value to the `methodMap` indexes above.
				lookupLevel: function lookupLevel(level) {
					if (typeof level === 'string') {
						var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase());
						if (levelMap >= 0) {
							level = levelMap;
						} else {
							level = parseInt(level, 10);
						}
					}

					return level;
				},

				// Can be overridden in the host environment
				log: function log(level) {
					level = logger.lookupLevel(level);

					if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) {
						var method = logger.methodMap[level];
						if (!console[method]) {
							// eslint-disable-line no-console
							method = 'log';
						}

						for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
							message[_key - 1] = arguments[_key];
						}

						console[method].apply(console, message); // eslint-disable-line no-console
					}
				}
			};

			exports['default'] = logger;
			module.exports = exports['default'];

			/***/ },
		/* 17 */
		/***/ function(module, exports) {

			// Build out our basic SafeString type
			'use strict';

			exports.__esModule = true;
			function SafeString(string) {
				this.string = string;
			}

			SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
				return '' + this.string;
			};

			exports['default'] = SafeString;
			module.exports = exports['default'];

			/***/ },
		/* 18 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireWildcard = __webpack_require__(1)['default'];

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;
			exports.checkRevision = checkRevision;
			exports.template = template;
			exports.wrapProgram = wrapProgram;
			exports.resolvePartial = resolvePartial;
			exports.invokePartial = invokePartial;
			exports.noop = noop;

			var _utils = __webpack_require__(4);

			var Utils = _interopRequireWildcard(_utils);

			var _exception = __webpack_require__(5);

			var _exception2 = _interopRequireDefault(_exception);

			var _base = __webpack_require__(3);

			function checkRevision(compilerInfo) {
				var compilerRevision = compilerInfo && compilerInfo[0] || 1,
					currentRevision = _base.COMPILER_REVISION;

				if (compilerRevision !== currentRevision) {
					if (compilerRevision < currentRevision) {
						var runtimeVersions = _base.REVISION_CHANGES[currentRevision],
							compilerVersions = _base.REVISION_CHANGES[compilerRevision];
						throw new _exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');
					} else {
						// Use the embedded version info since the runtime doesn't know about this revision yet
						throw new _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').');
					}
				}
			}

			function template(templateSpec, env) {
				/* istanbul ignore next */
				if (!env) {
					throw new _exception2['default']('No environment passed to template');
				}
				if (!templateSpec || !templateSpec.main) {
					throw new _exception2['default']('Unknown template object: ' + typeof templateSpec);
				}

				templateSpec.main.decorator = templateSpec.main_d;

				// Note: Using env.VM references rather than local var references throughout this section to allow
				// for external users to override these as psuedo-supported APIs.
				env.VM.checkRevision(templateSpec.compiler);

				function invokePartialWrapper(partial, context, options) {
					if (options.hash) {
						context = Utils.extend({}, context, options.hash);
						if (options.ids) {
							options.ids[0] = true;
						}
					}

					partial = env.VM.resolvePartial.call(this, partial, context, options);
					var result = env.VM.invokePartial.call(this, partial, context, options);

					if (result == null && env.compile) {
						options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
						result = options.partials[options.name](context, options);
					}
					if (result != null) {
						if (options.indent) {
							var lines = result.split('\n');
							for (var i = 0, l = lines.length; i < l; i++) {
								if (!lines[i] && i + 1 === l) {
									break;
								}

								lines[i] = options.indent + lines[i];
							}
							result = lines.join('\n');
						}
						return result;
					} else {
						throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
					}
				}

				// Just add water
				var container = {
					strict: function strict(obj, name) {
						if (!(name in obj)) {
							throw new _exception2['default']('"' + name + '" not defined in ' + obj);
						}
						return obj[name];
					},
					lookup: function lookup(depths, name) {
						var len = depths.length;
						for (var i = 0; i < len; i++) {
							if (depths[i] && depths[i][name] != null) {
								return depths[i][name];
							}
						}
					},
					lambda: function lambda(current, context) {
						return typeof current === 'function' ? current.call(context) : current;
					},

					escapeExpression: Utils.escapeExpression,
					invokePartial: invokePartialWrapper,

					fn: function fn(i) {
						var ret = templateSpec[i];
						ret.decorator = templateSpec[i + '_d'];
						return ret;
					},

					programs: [],
					program: function program(i, data, declaredBlockParams, blockParams, depths) {
						var programWrapper = this.programs[i],
							fn = this.fn(i);
						if (data || depths || blockParams || declaredBlockParams) {
							programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
						} else if (!programWrapper) {
							programWrapper = this.programs[i] = wrapProgram(this, i, fn);
						}
						return programWrapper;
					},

					data: function data(value, depth) {
						while (value && depth--) {
							value = value._parent;
						}
						return value;
					},
					merge: function merge(param, common) {
						var obj = param || common;

						if (param && common && param !== common) {
							obj = Utils.extend({}, common, param);
						}

						return obj;
					},

					noop: env.VM.noop,
					compilerInfo: templateSpec.compiler
				};

				function ret(context) {
					var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

					var data = options.data;

					ret._setup(options);
					if (!options.partial && templateSpec.useData) {
						data = initData(context, data);
					}
					var depths = undefined,
						blockParams = templateSpec.useBlockParams ? [] : undefined;
					if (templateSpec.useDepths) {
						if (options.depths) {
							depths = context !== options.depths[0] ? [context].concat(options.depths) : options.depths;
						} else {
							depths = [context];
						}
					}

					function main(context /*, options*/) {
						return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);
					}
					main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);
					return main(context, options);
				}
				ret.isTop = true;

				ret._setup = function (options) {
					if (!options.partial) {
						container.helpers = container.merge(options.helpers, env.helpers);

						if (templateSpec.usePartial) {
							container.partials = container.merge(options.partials, env.partials);
						}
						if (templateSpec.usePartial || templateSpec.useDecorators) {
							container.decorators = container.merge(options.decorators, env.decorators);
						}
					} else {
						container.helpers = options.helpers;
						container.partials = options.partials;
						container.decorators = options.decorators;
					}
				};

				ret._child = function (i, data, blockParams, depths) {
					if (templateSpec.useBlockParams && !blockParams) {
						throw new _exception2['default']('must pass block params');
					}
					if (templateSpec.useDepths && !depths) {
						throw new _exception2['default']('must pass parent depths');
					}

					return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
				};
				return ret;
			}

			function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
				function prog(context) {
					var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

					var currentDepths = depths;
					if (depths && context !== depths[0]) {
						currentDepths = [context].concat(depths);
					}

					return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
				}

				prog = executeDecorators(fn, prog, container, depths, data, blockParams);

				prog.program = i;
				prog.depth = depths ? depths.length : 0;
				prog.blockParams = declaredBlockParams || 0;
				return prog;
			}

			function resolvePartial(partial, context, options) {
				if (!partial) {
					if (options.name === '@partial-block') {
						partial = options.data['partial-block'];
					} else {
						partial = options.partials[options.name];
					}
				} else if (!partial.call && !options.name) {
					// This is a dynamic partial that returned a string
					options.name = partial;
					partial = options.partials[partial];
				}
				return partial;
			}

			function invokePartial(partial, context, options) {
				options.partial = true;
				if (options.ids) {
					options.data.contextPath = options.ids[0] || options.data.contextPath;
				}

				var partialBlock = undefined;
				if (options.fn && options.fn !== noop) {
					options.data = _base.createFrame(options.data);
					partialBlock = options.data['partial-block'] = options.fn;

					if (partialBlock.partials) {
						options.partials = Utils.extend({}, options.partials, partialBlock.partials);
					}
				}

				if (partial === undefined && partialBlock) {
					partial = partialBlock;
				}

				if (partial === undefined) {
					throw new _exception2['default']('The partial ' + options.name + ' could not be found');
				} else if (partial instanceof Function) {
					return partial(context, options);
				}
			}

			function noop() {
				return '';
			}

			function initData(context, data) {
				if (!data || !('root' in data)) {
					data = data ? _base.createFrame(data) : {};
					data.root = context;
				}
				return data;
			}

			function executeDecorators(fn, prog, container, depths, data, blockParams) {
				if (fn.decorator) {
					var props = {};
					prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
					Utils.extend(prog, props);
				}
				return prog;
			}

			/***/ },
		/* 19 */
		/***/ function(module, exports) {

			/* WEBPACK VAR INJECTION */(function(global) {/* global window */
				'use strict';

				exports.__esModule = true;

				exports['default'] = function (Handlebars) {
					/* istanbul ignore next */
					var root = typeof global !== 'undefined' ? global : window,
						$Handlebars = root.Handlebars;
					/* istanbul ignore next */
					Handlebars.noConflict = function () {
						if (root.Handlebars === Handlebars) {
							root.Handlebars = $Handlebars;
						}
						return Handlebars;
					};
				};

				module.exports = exports['default'];
				/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

			/***/ }
		/******/ ])
});
;
/**
 *    xbe4x is javascript implementation of the original ECMAScript for XML (E4X)
 *    Specification (ECMA-357) December 2005. This implementation is designed to emulate
 *    the implementation that is used in SpiderMonkey (Mozilla's JavaScript(TM) Engine)
 *    and therefore Firefox, Thunderbird, and most other Gecko based applications.
 *    Because the Mozilla implementation leaves out certain features of the
 *    specification, so does xbe4x. Please read the README file for a further
 *    explanation of these issues.
 *
 *
 *    @author Sam Shull <http://samshull.blogspot.com/>
 *    @version 0.1
 *
 *    @copyright Copyright (c) 2009 Sam Shull <http://samshull.blogspot.com/>
 *    @license <http://www.opensource.org/licenses/mit-license.html>
 *
 *    Permission is hereby granted, free of charge, to any person obtaining a copy
 *    of this software and associated documentation files (the "Software"), to deal
 *    in the Software without restriction, including without limitation the rights
 *    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *    copies of the Software, and to permit persons to whom the Software is
 *    furnished to do so, subject to the following conditions:
 *
 *    The above copyright notice and this permission notice shall be included in
 *    all copies or substantial portions of the Software.
 *
 *    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *    THE SOFTWARE.
 *
 *
 *    CHANGES:
 */

//this doesn't load if window.XML is already defined
if (!this.XML)
{
    (function ()
    {
        /*
         *
         *
         */
        var undefined, p,
            window                       = this,
            dns                          = [],
            defaultNamespace             = "",
            ELEMENT_NODE                 = 1,
            ATTRIBUTE_NODE               = 2,
            TEXT_NODE                    = 3,
            CDATA_SECTION_NODE           = 4,
            ENTITY_REFERENCE_NODE        = 5,
            ENTITY_NODE                  = 6,
            PROCESSING_INSTRUCTION_NODE  = 7,
            COMMENT_NODE                 = 8,
            DOCUMENT_NODE                = 9,
            DOCUMENT_TYPE_NODE           = 10,
            DOCUMENT_FRAGMENT_NODE       = 11,
            NOTATION_NODE                = 12,
            isNSDef                      = /^xmlns:([\w\-]+)/i,
            toString                     = ({}).toString,
            propertyIsEnumerable         = ({}).propertyIsEnumerable,
            hasOwnProperty               = ({}).hasOwnProperty,
            defaultXMLProperties         = ",prototype,ignoreComments,ignoreProcessingInstructions,ignoreWhitespace," +
                "prettyPrinting,prettyIndent,settings,defaultSettings,setSettings,settings," +
                "propertyIsEnumerable,hasOwnProperty,_setDefaultNamespace,",
            defaultXMLPrototype          = ",_Class,_Name,_Parent,_Value,_InScopeNamespaces,_Attributes,_Children,_Node",
            defaultXMLListPrototype      = ",_Class,_Value,_Children,_TargetObject,_TargetProperty",
            xmlDoc                       = parse("<x/>"),
            piName                       = /^[\w\-]+\s*/,
            XSLT_NS                      = "http://www.w3.org/1999/XSL/Transform";

        /**
         *
         *
         *    @param String | XML $string
         *    @returns XML
         *    @throws SyntaxError
         */
        function XML ($string)
        {
            if (!(this instanceof XML))
            {
                return ToXML($string);
            }

            var x, i, l;

            this._Class = "text";

            this._Name = null;

            this._Value = null;

            this._Parent = null;

            this._InScopeNamespaces = {};

            this._DefaultNamespace = null;

            this._Attributes = {};

            this._Children = [];

            this[0] = this;

            /**
             *
             *
             *
             */
            switch (typeof($string))
            {
                case "undefined":
                case "null":
                    break;
                case "number":
                case "boolean":    $string = ToString($string);
                case "string":

                    x = ToXML(trim($string));
                    if (x)
                    {
                        if (x.length() ===1)
                        {
                            this._Class = x._Class;
                            this._Name = x._Name;
                            this._Value = x._Value;
                            this._InScopeNamespaces = x._InScopeNamespaces;
                            this._DefaultNamespace = x._DefaultNamespace;
                            this._Attributes = x._Attributes;

                            for (i = 0, l = x._Children.length; i < l; ++i)
                            {
                                this._Children[i] = x._Children[i];
                                this._Children[i]._Parent = this;
                            }

                            break;
                        }
                    }

                    throw new SyntaxError();
                    break;
                default:
                    if ($string instanceof XML)
                    {
                        if ($string.length() ===1)
                        {
                            x = $string;
                            this._Class = x._Class;
                            this._Name = x._Name;
                            this._Value = x._Value;
                            this._InScopeNamespaces = x._InScopeNamespaces;
                            this._DefaultNamespace = x._DefaultNamespace;
                            this._Attributes = x._Attributes;

                            for (i = 0, l = x._Children.length; i < l; ++i)
                            {
                                this._Children[i] = x._Children[i];
                                this._Children[i]._Parent = this;
                            }
                        }
                    }
                    break;
            }
        }

        /**
         *    Ignore XML comments. (Default: true.)
         *
         *    @static
         *    @param Namespace ns
         *    @returns void
         */
        XML.setDefaultNamespace = function (ns)
        {
            dns.unshift(defaultNamespace || "");
            defaultNamespace = Namespace(ns);
            return null;
        };

        /**
         *  Use this function to restore the default namespace
         *  to the previous namespace
         *
         */
        XML.restoreDefaultNamespace = function ()
        {
            defaultNamespace = dns.shift() || "";
            return null;
        };

        /**
         *
         *
         *
         */
        XML.load = function (pathToFile, onload)
        {
            var xhr = isActiveXSupported("Microsoft.XMLHTTP") && new ActiveXObject("Microsoft.XMLHTTP") || new XMLHttpRequest(),
                async = ({}).toString.call(onload || {}) == "[object Function]";

            xhr.open("GET", pathToFile, async);

            if (async)
            {
                if (!!xhr.addEventListener)
                {
                    xhr.addEventListener("load", loaded, false);
                }
                else
                {
                    xhr.onreadystatechange = function ()
                    {
                        if (xhr.readyState == 4 && xhr.status == 200)
                        {
                            loaded();
                        }
                    };
                }
            }

            xhr.send(null);

            return async ? xhr : loaded(1);

            function loaded (ret)
            {
                var x = new XML((xhr.responseText||"").replace(/\s*<\?xml.*?\?>/,""));
                return ret ? x : onload(x);
            }
        };

        /**
         *    Ignore XML comments. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreComments = true;

        /**
         *    Ignore XML processing instructions. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreProcessingInstructions = true;

        /**
         *    Ignore whitespace. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreWhitespace = true;

        /**
         *    Pretty-print XML output with toXMLString() etc. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.prettyPrinting = true;

        /**
         *    Pretty indent level for child nodes. (Default: 2.)
         *
         *    @static
         *    @var Number
         */
        XML.prettyIndent = 2;

        //There are also three methods to more easily apply and restore settings for use, say, within a function.

        /**
         *    Get an Object containing the above settings.
         *
         *    @static
         *    @returns Object
         */
        XML.settings = function ()
        {
            return {
                ignoreComments:                 XML.ignoreComments,
                ignoreProcessingInstructions:   XML.ignoreProcessingInstructions,
                ignoreWhitespace:               XML.ignoreWhitespace,
                prettyPrinting:                 XML.prettyPrinting,
                prettyIndent:                   XML.prettyIndent
            };
        };

        /**
         *    Get an object containing the default settings.
         *
         *    @static
         *    @returns Object
         */
        XML.defaultSettings = function ()
        {
            return {
                ignoreComments:                 true,
                ignoreProcessingInstructions:   true,
                ignoreWhitespace:               true,
                prettyPrinting:                 true,
                prettyIndent:                   2
            };
        };

        /**
         *    Set XML settings from, e.g., an object returned by XML.settings().
         *
         *
         *    @static
         *    @param Object settings
         *    @returns void
         */
        XML.setSettings = function (settings)
        {
            var p;
            settings = settings || XML.settings();
            for (p in settings)
            {
                switch (p)
                {
                    case "ignoreComments":                   XML.ignoreComments = !!settings[p];
                    case "ignoreProcessingInstructions":     XML.ignoreProcessingInstructions = !!settings[p];
                    case "ignoreWhitespace":                 XML.ignoreWhitespace = !!settings[p];
                    case "prettyPrinting":                   XML.prettyPrinting = !!settings[p];
                    case "prettyIndent":                     XML.prettyIndent = parseInt(settings[p]) || 0;
                }
            }
            return null;
        };

        /**
         *
         *
         *    @static
         *    @param String name
         *    @returns Boolean
         */
        XML.hasOwnProperty = function (name)
        {
            return defaultXMLProperties.indexOf("," + name + ",") ===-1
                && hasOwnProperty.call(XML, name);
        };

        /**
         *
         *
         *    @static
         *    @param String name
         *    @returns Boolean
         */
        XML.propertyIsEnumerable = function (name)
        {
            return name !== "prototype"
                && name in XML
                && toString.call(XML[name]) != "[object Function]"
                && propertyIsEnumerable.call(XML, name);
        };

        /**
         *
         *
         *    @static
         *    @returns String
         */
        XML.toString = function ()
        {
            return "function XML() {\n [native code] \n}";
        };

        /**
         *
         *
         *    @param String | Namespace namespace
         *    @returns XML
         */
        XML.prototype.addNamespace = function (namespace)
        {
            AddInScopeNamespace.call(this, Namespace(namespace));
            return this;
        };

        /**
         *
         *
         *    @param String child
         *    @returns XML
         */
        XML.prototype.appendChild = function (child,isChildElement)
        {
            isChildElement = isChildElement !== undefined ? isChildElement : false;
            var children = Get.call(this, "*");
            children.Put(children.length(), child,isChildElement);
            return this;
        };

        /**
         *
         *
         *    @param String | AttributeName | QName attributeName
         *    @returns XML
         */
        XML.prototype.attribute = function (attributeName)
        {
            return Get.call(this, ToAttributeName(attributeName), true);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.attributes = function ()
        {
            return Get.call(this, ToAttributeName("*"));
        };

        /**
         *
         *
         *    @param String propertyName
         *    @returns XMLList
         */
        XML.prototype.child = function (propertyName)
        {
            var temporary;

            if (parseInt(propertyName)+"" == propertyName)
            {
                temporary = Get.call(this, "*");
                temporary = GetList.call(temporary, propertyName);
                return temporary || new XMLList();
            }

            temporary = ToXMLList( Get.call(this, propertyName) );

            return temporary;
        };

        /**
         *
         *
         *    @returns Number
         */
        XML.prototype.childIndex = function ()
        {
            var parent = this._Parent, q, l;

            if (!parent || this._Class === "attribute")
            {
                return -1;
            }

            for (q = 0, l = parent._Children.length; q < l; ++q)
            {
                if (parent._Children[q] === this)
                {
                    return q;
                }
            }

            return -1;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.children = function ()
        {
            return Get.call(this, "*");
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.comments = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "comment")
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns Boolean
         */
        XML.prototype.contains = function (value)
        {
            return this == value;
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.copy = function ()
        {
            return DeepCopy.call(this);
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XML.prototype.descendants = function (name)
        {
            return Descendants.call(this, name || "*");
        };

        /**
         *
         *
         *    @param String | QName | AttributeName name
         *    @returns XMLList
         */
        XML.prototype.elements = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = name;

            for (; i < l; ++i)
            {
                if (
                    this._Children[i]._Class === "element"
                    && (name.localName === "*" || name.localName === this._Children[i]._Name.localName)
                    && (name.uri == null || name.uri === this._Children[i]._Name.uri)
                )
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XML.prototype.hasOwnProperty = function (name)
        {
            return HasProperty.call(this, name) || (defaultXMLPrototype.indexOf("," + name +",") === -1 && hasOwnProperty.call(this, name));
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XML.prototype.hasComplexContent = function ()
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XML.prototype.hasSimpleContent = function ()
        {
            if ((",comment,processing-instruction,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return false;
                }
            }

            return true;
        };

        /**
         *
         *
         *    @returns Array
         */
        XML.prototype.inScopeNamespaces = function ()
        {
            var y = this, inScopeNS = {}, p, a = [];

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!inScopeNS[p])
                    {
                        inScopeNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y.parent();
            }

            if (this._DefaultNamespace)
            {
                inScopeNS[""] = this._DefaultNamespace;
            }

            for (p in inScopeNS)
            {
                a[a.length] = inScopeNS[p];
            }

            return a;
        };

        /**
         *
         *
         *    @param XML child1
         *    @param XML child2
         *    @returns XML | null
         */
        XML.prototype.insertChildAfter = function (child1, child2)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            /*
             //this is disabled, because it doesn't work in
             //Firefox according to the spec
             if (!child2)
             {
             Insert.call(this, 0, child1);
             return this;
             }
             else if (!child1)
             {
             Insert.call(this, 0, child2);
             return this;
             }
             else
             */

            if (!child1){
                Insert.call(this, 0, child2);
                return this;
            }
            if (!child2){
                Insert.call(this, 0, child1);
                return this;
            }

            if (child1 instanceof XML)
            {
                Insert.call(this, child1.childIndex() + 1, child2);
                return this;
            }

            return null;
        };

        /**
         *
         *
         *
         *    @param XML child1
         *    @param XML child2
         *    @returns XML | null
         */
        XML.prototype.insertChildBefore = function (child1, child2)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            /*
             //this is disabled, because it doesn't work in
             //Firefox according to the spec
             if (!child1)
             {
             Insert.call(this, this._Children.length, child2);
             return this;
             }
             else if (!child2)
             {
             Insert.call(this, this._Children.length, child1);
             return this;
             }
             else
             */

            if (child1 instanceof XML)
            {
                Insert.call(this, child1.childIndex(), child2);
                return this;
            }

            return null;
        };

        /**
         *
         *
         *    @returns Number
         */
        XML.prototype.length = function ()
        {
            return 1;
        };

        /**
         *
         *
         *    @returns String | null
         */
        XML.prototype.localName = function ()
        {
            return this._Name === null ? null : this._Name.localName;
        };

        /**
         *
         *
         *    return QName
         */
        XML.prototype.name = function ()
        {
            return this._Name;
        };

        /**
         *
         *
         *    @param String prefix
         *    @returns Namespace
         */
        XML.prototype.namespace = function (prefix)
        {
            var y = this, inScopeNS = {}, p;

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!inScopeNS[p])
                    {
                        inScopeNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y.parent();
            }

            if (prefix === undefined)
            {
                if ((",comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
                {
                    return null;
                }

                return GetNamespace(this._Name, inScopeNS);
            }

            prefix = ToString(prefix);

            for (p in inScopeNS)
            {
                if (inScopeNS[p].prefix === prefix)
                {
                    return inScopeNS[p];
                }
            }

            return null;
        };

        /**
         *
         *
         *    @returns Array
         */
        XML.prototype.namespaceDeclarations = function ()
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return [];
            }

            var a = [], y = this._Parent, ancestorNS = {}, p;

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!ancestorNS[p])
                    {
                        ancestorNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y._Parent;
            }

            for (p in this._InScopeNamespaces)
            {
                if (p != "" && (!ancestorNS[p] || ancestorNS[p].uri != this._InScopeNamespaces[p]))
                {
                    a[a.length] = this._InScopeNamespaces[p];
                }
                else if(p === "" && !this._Parent)
                {
                    a[a.length] = this._InScopeNamespaces[p];
                }
            }

            return a;
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.nodeKind = function ()
        {
            return this._Class;
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.normalize = function ()
        {
            for (var i = 0, l = this._Children.length; i < l;)
            {
                if (this._Children[i]._Class === "element")
                {
                    this._Children[i].normalize();
                    ++i;
                }
                else if (this._Children[i]._Class === "text")
                {
                    while (i+1 < this._Children.length && this._Children[i+1]._Class === "text")
                    {
                        this._Children[i]._Value = (this._Children[i]._Value || "") + (this._Children[i+1]._Value || "");
                        DeleteByIndex.call(this, i+1);
                    }

                    if (this._Children[i]._Value.length === 0)
                    {
                        DeleteByIndex.call(this, i);
                    }
                    else
                    {
                        ++i;
                    }
                }
                else
                {
                    ++i;
                }
            }

            return this;
        };

        /**
         *
         *
         *    @returns XML | null
         */
        XML.prototype.parent = function ()
        {
            return this._Parent;
        };

        /**
         *
         *
         *    @param String name
         *    @returns XMLList
         */
        XML.prototype.processingInstructions = function (name)
        {
            name = ToXMLName(name || "*");

            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "processing-instruction"
                    && (name.localName === "*" || name.localName === this._Children[i]._Name.localName)
                )
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.prependChild = function (value)
        {
            Insert.call(this, 0, value);
            return this;
        };


        XML.prototype.findFirstElement = function (value)
        {
            var list = [];
            list = this.elements(value)._Children;
            if(list.length == 0){
                var children = this.children();
                var xml;
                for(var i=0;i<children.length();i++){
                    xml = children[i];
                    var sublist = xml.findFirstElement(value);
                    if(sublist.length>0)
                        return sublist;
                }
            }
            return list;
        };


        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XML.prototype.propertyIsEnumerable = function (name)
        {
            return name == "0";
        };

        /**
         *
         *
         *    @param Namespace | String namespace
         *    @returns XML
         */
        XML.prototype.removeNamespace = function (namespace)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return this;
            }

            var ns = Namespace(namespace), thisNS = GetNamespace(this._Name, this._InScopeNamespaces), p, l;

            if (thisNS == ns)
            {
                return this;
            }

            /*
             //firefox does not remove the references to the
             //namespaces in attributes -- so we wont either
             for (p in this._Attributes)
             {
             if (GetNamespace(this._Attributes[p]._Name, this._InScopeNamespaces).uri == ns.uri)
             {
             this._Attributes[p]._Name = new QName(ns, this._Attributes[p].localName());
             }
             }
             //*/

            if (ns.prefix == undefined)
            {
                for (p in this._InScopeNamespaces)
                {
                    if (this._InScopeNamespaces[p].uri === ns.uri)
                    {
                        try{
                            this._InScopeNamespaces[p] = null;
                            delete this._InScopeNamespaces[p];
                        }catch(e){}
                    }
                }
            }
            else if (this._InScopeNamespaces[ns.prefix] && this._InScopeNamespaces[ns.prefix].uri === ns.uri)
            {
                try{
                    this._InScopeNamespaces[ns.prefix] = null;
                    delete this._InScopeNamespaces[ns.prefix];
                }catch(e){}
            }

            for (p = 0, l = this._Children.length; p < l; ++p)
            {
                if (this._Children[p]._Class === "element")
                {
                    this._Children[p].removeNamespace(ns);
                }
            }

            return this;
        };

        /**
         *
         *
         *    @param String propertyName
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.replace = function (propertyName, value)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return this;
            }

            var c = value instanceof XML ? DeepCopy.call(value) : ToString(value), n, i, k;

            if (parseInt(propertyName)+"" == propertyName)
            {
                Replace.call(this, propertyName, c);
                return this;
            }

            /*
             Basically Firefox does not appear to follow the rules set forth in the spec
             so, we are just going to fix this so that we do what firefox does
             if the propertyName is not an integer:
             if value is a XMLList setChildren
             otherwise do nothing
             */

            if (c instanceof XMLList)
            {
                this.setChildren(c);
            }

            return this;

            /*
             Leave the rest of these rules in place, just in case
             */

            n = QName(propertyName);
            k = this._Children.length;

            while (--k > -1)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName===n.localName))
                    && (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri ))
                )
                {
                    if (i !== undefined)
                    {
                        DeleteByIndex.call(this, i);
                    }

                    i = k;
                }
            }

            if (i !== undefined)
            {
                Replace.call(this, i, c);
            }

            return this;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.setChildren = function (value)
        {
            this.Put("*", value);
            return this;
        };

        /**
         *
         *
         *    @param String name
         *    @returns void
         */
        XML.prototype.setLocalName = function (name)
        {
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._Name.localName = name instanceof QName ? name.localName : ToString(name);
        };

        /**
         *
         *
         *    @param QName | String name
         *    @returns null
         */
        XML.prototype.setName = function (name)
        {
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            if (name instanceof QName && name.uri == null)
            {
                name = name.localName;
            }

            var n = QName(name);

            if (this._Class === "processing-instruction")
            {
                n.uri = "";
            }

            this._DefaultNamespace = new Namespace(n.prefix, n.uri);

            this._Name = n;

            if (this._Class === "attribute")
            {
                if (this._Parent)
                {
                    AddInScopeNamespace.call(this._Parent, this._DefaultNamespace);
                }
            }
            else if (this._Class === "element")
            {
                AddInScopeNamespace.call(this, this._DefaultNamespace);
            }
            else if ((",comment,text,processing-instruction,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._Name = new QName(this._DefaultNamespace, this._Name.localName);

            return null;
        };

        /**
         *
         *
         *    @param Namespace | String ns
         *    @returns null
         */
        XML.prototype.setNamespace = function (ns)
        {
            //processing-instruction,
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._DefaultNamespace = Namespace(ns);

            this._Name = new QName(this._DefaultNamespace, this._Name.localName);

            if (this._Class === "attribute")
            {
                if (this._Parent)
                {
                    AddInScopeNamespace.call(this._Parent, this._DefaultNamespace);
                }
            }
            else if (this._Class === "element")
            {
                AddInScopeNamespace.call(this, this._DefaultNamespace);
            }

            return null;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.text = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "text")
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.toString = function ()
        {
            return ToString(this);
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.toXMLString = function ()
        {
            return ToXMLString(this);
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.valueOf = function ()
        {
            return this;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML | String Value
         *    @returns null
         *    @throws TypeError
         */
        XML.prototype.Put = function (PropertyName, Value)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                throw new TypeError();
            }

            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var c = (!(Value instanceof XML) || (",text,attribute,").indexOf("," + Value._Class+",") > -1)
                    ? ToString(Value)
                    : DeepCopy.call(Value),
                n = ToXMLName(PropertyName),
                s, i, l, a = null, primitiveAssign, k;

            if (n instanceof AttributeName)
            {
                if (!isXMLName(n._Name))
                {
                    return false;
                }

                if (c instanceof XMLList)
                {
                    if (c._Children.length === 0)
                    {
                        c = "";
                    }
                    else
                    {
                        s = ToString(c[0]);

                        for (i = 1, l = c._Children.length; i < l; ++i)
                        {
                            s += " " + ToString(c[i]);
                        }

                        c = s;
                    }
                }
                else
                {
                    c = ToString(c);
                }

                for (i in this._Attributes)
                {
                    if (
                        (n._Name.localName === this._Attributes[i]._Name.localName)
                        && (n._Name.uri === null || n._Name.uri === this._Attributes[i]._Name.uri)
                    )
                    {
                        if (a == null)
                        {
                            a = this._Attributes[i];
                        }
                        else
                        {
                            this.Delete(this._Attributes[i]._Name);
                        }
                    }
                }

                if (a == null)
                {
                    a = new XML();
                    a._Parent = this;
                    a._Class = "attribute";
                    a._Name = n._Name.uri == null
                        ? new QName(new Namespace(), n._Name)
                        : new QName(new Namespace(n._Name.uri), n._Name.localName);

                    this._Attributes[(a._Name._Prefix ? a._Name._Prefix + ":" : "") + a._Name.localName] = a;

                    AddInScopeNamespace.call(this, GetNamespace(a._Name));
                }

                a._Value = c;

                return null;
            }

            if (!isXMLName(n) && n.localName != "*")
            {
                return null;
            }

            i = undefined;

            primitiveAssign = !(c instanceof XML) && n.localName != "*";

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName===n.localName))
                    &&
                    (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                )
                {
                    if (i != undefined)
                    {
                        DeleteByIndex.call(this, ToString(i));
                    }
                    else
                    {
                        i = k;
                    }
                }
            }

            if (i == undefined)
            {
                i = this._Children.length;

                if (primitiveAssign)
                {
                    a = new XML();
                    a._Class = "element";
                    a._Parent = this;
                    a._Name = n.uri == null
                        ? new QName(GetDefaultNamespace(), n)
                        : new QName(n);

                    Replace.call(this, ToString(i), a);

                    AddInScopeNamespace.call(a, GetNamespace(a._Name));
                }
            }

            if (primitiveAssign)
            {
                s = ToString(c);

                if (s != "")
                {
                    Replace.call(this._Children[i], "0", s);
                }
            }
            else
            {
                Replace.call(this, ToString(i), c);
            }

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns null
         *    @throws TypeError
         */
        XML.prototype.Delete = function (PropertyName)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                throw new TypeError();
            }

            var n = ToXMLName(PropertyName), k, dp = 0, q = 0, l;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName)
                        &&
                        (n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri)
                    )
                    {
                        this._Attributes[k]._Parent = null;
                        try{
                            delete this._Attributes[k];
                        }catch(e){}
                    }
                }

                return true;
            }

            for (l = this._Children.length; q < l; ++q)
            {
                if (
                    (n.localName === "*" || (this._Children[q]._Class === "element" && this._Children[q]._Name.localName === n.localName))
                    &&
                    (n.uri == null || (this._Children[q]._Class === "element" && n.uri === this._Children[q]._Name.uri))
                )
                {
                    DeleteByIndex.call(this, q);
                    ++dp;
                }
                else if (dp > 0)
                {
                    this._Children[q - dp] = this._Children[q];
                }
            }


            return true;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns Boolean
         */
        XML.prototype.Equals = function (Value)
        {
            if (!(Value instanceof XML))
            {
                return false;
            }
            if (this._Class !== Value._Class)
            {
                return false;
            }
            if (this._Children.length !== Value._Children.length)
            {
                return false;
            }
            if (this._Value !== Value._Value)
            {
                return false;
            }
            if (this._Name !== null)
            {
                if (Value._Name === null)
                {
                    return false;
                }
                if (Value._Name.localName !== this._Name.localName)
                {
                    return false;
                }
                if (Value._Name.uri !== this._Name.uri)
                {
                    return false;
                }
            }
            else if (Value._Name !== null)
            {
                return false;
            }

            if (count(this._Attributes) !== count(Value._Attributes))
            {
                return false;
            }

            var a, b, k, l;

            for (k in this._Attributes)
            {
                a = this._Attributes[k];

                b = Value._Attributes[k];

                if (!b || b._Name.localName !== a._Name.localName || b._Name.uri !== a._Name.uri || b._Value !== a._Value)
                {
                    return false;
                }
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                a = this._Children[k];

                b = Value._Children[k];

                if (!arguments.callee.call(a, b))
                {
                    return false;
                }
            }

            return true;
        };

        //extensions

        /*
         * e4x.js
         *
         * A JavaScript library that implements the optional E4X features described in
         * ECMA-357 2nd Edition Annex A if they are not already implemented.
         *
         * 2010-03-13
         *
         * By Elijah Grey, http://eligrey.com
         * License: The X11/MIT license (see COPYING.md)
         *
         * Changes:
         *    By Sam Shull, http://samshull.blogspot.com
         *    Just a litlle simplifying for implementation
         */

        /*global document, XML, XMLList, DOMParser, XMLSerializer, XPathResult */

        /*jslint undef: true, nomen: true, eqeqeq: true, bitwise: true, regexp: true,
         newcap: true, immed: true, maxerr: 1000, maxlen: 90 */

        /**
         *
         *
         *
         */
        XML.prototype.domNode = function ()
        {
            return adoptNode(document, xmlToDomNode(this));
        };

        /**
         *
         *
         *
         */
        XML.prototype.domNodeList = function ()
        {
            if (this.length() < 0)
            {
                throw new Error();
            }

            return adoptNode(document, createDocumentFrom(this).documentElement).childNodes;
        };

        /**
         *
         *
         *
         */
        XML.prototype.xpath = function (xpathExp)
        {
            var res = new XMLList,
                i = 0, l = this.length(),
                xpr;

            if (l !== 1)
            {
                for (; i < l; ++i)
                {
                    res.Append(this[i].xpath(xpathExp));
                }

                return res;
            }

            xpr = evaluate(createDocumentFrom(this), xpathExp, this);

            for (l=xpr.length; i < l; ++i)
            {
                res.Append(ToXML(xpr[i]));
            }

            return res;
        };

        /**
         *
         *
         *
         */
        XML.prototype.transform = function (xslt, params)
        {
            if (!xslt instanceof XML)
            {
                throw new TypeError();
            }

            var doc, res, i, l = this.length(), c;

            if (l > 1)
            {
                res = new XMLList();
                for (i = 0; i < l; ++i)
                {
                    res.Append(this[i].transform(xslt, params));
                }
                return res;
            }

            return transform(this, xslt, params);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        function XMLList ($string)
        {
            if (!(this instanceof XMLList))
            {
                return ToXMLList($string || "");
            }

            this._Class = "XMLList";

            this._Value = undefined;


            this._TargetObject = null;

            this._TargetProperty = null;

            this._Children = [];

            this[0] = null;

            if ($string)
            {
                var list = ToXMLList($string), i = 0, l = list._Children.length;
                this._Value = list._Value;

                for (;i < l; ++i)
                {
                    this._Children[i] = this[i] = list._Children[i];
                }
            }
        }

        /**
         *
         *
         *    @static
         *    @returns String
         *    @throws TypeError
         */
        XMLList.toString = function ()
        {
            return "function XMLList() {\n [native code] \n}";
        };

        XMLList.prototype = new XML();

        var ignore = {xpath:1,domNodeList:1,transform:1};

        for (p in XMLList.prototype)
        {
            if (ignore[p])
            {
                continue;
            }

            XMLList.prototype[p] = (function(p)
            {
                return function ()
                {
                    if (this._Children.length != 1)
                    {
                        throw new TypeError("cannot call " + p + " method on an XML list with " + this._Children.length + " elements");
                    }

                    return XML.prototype[p].apply(this[0], arguments);
                };
            })(p);
        }

        try{
            delete XMLList.prototype._Attributes;
            delete XMLList.prototype._InScopeNamespaces;
        }catch(e){}

        /**
         *
         *
         *    @param String | AttributeName attributeName
         *    @returns XMLList
         */
        XMLList.prototype.attribute = function (attributeName)
        {
            return GetList.call(this, ToAttributeName(attributeName));
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.attributes = function ()
        {
            return GetList.call(this, ToAttributeName("*"));
        };

        /**
         *
         *
         *    @param String | QName propertyName
         *    @returns XMLList
         */
        XMLList.prototype.child = function (propertyName)
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                r = this[i].child(propertyName);

                if (r._Children.length > 0)
                {
                    list.Append(r);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.children = function ()
        {
            return GetList.call(this, "*");
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.comments = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].comments();

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns Boolean
         */
        XMLList.prototype.contains = function (value)
        {
            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this[i] == value)
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.copy = function ()
        {
            return DeepCopyList.call(this);
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.descendants = function (name)
        {
            return DescendantsList.call(this, name || "*");
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.elements = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;
            list._TargetProperty = name;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].elements(name);

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XMLList.prototype.hasOwnProperty = function (name)
        {
            return HasProperty.call(this, name)
                || (defaultXMLListProperties.indexOf("," + name + ",") === -1 && hasOwnProperty.call(this, name));
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XMLList.prototype.hasComplexContent = function ()
        {
            if (this._Children.length === 0)
            {
                return false;
            }

            if (this._Children.length === 1)
            {
                return this[0].hasComplexContent();
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XMLList.prototype.hasSimpleContent = function ()
        {
            if (this._Children.length === 1)
            {
                return this[0].hasSimpleContent();
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return false;
                }
            }

            return true;
        };

        /**
         *
         *
         *    @returns Number
         */
        XMLList.prototype.length = function ()
        {
            return this._Children.length;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.normalize = function ()
        {
            for (var i = 0, l = this._Children.length; i < l;)
            {
                if (this[i]._Class === "element")
                {
                    this[i].normalize();
                    ++i;
                }
                else if (this[i]._Class === "text")
                {
                    while (i+1 < this._Children.length && this[i+1]._Class === "text")
                    {
                        this[i]._Value = (this[i]._Value || "") + (this[i+1]._Value || "");
                        this.Delete(i+1);
                    }

                    if (this[i]._Value.length === 0)
                    {
                        this.Delete(i);
                    }
                    else
                    {
                        ++i;
                    }
                }
                else
                {
                    ++i;
                }
            }

            return this;
        };

        /**
         *
         *
         *    @returns XML | undefined
         */
        XMLList.prototype.parent = function ()
        {
            if (this._Children.length === 0)
            {
                return undefined;
            }

            for (var parent = this[0]._Parent, i = 1, l = this._Children.length; i < l; ++i)
            {
                if (this[i]._Parent != parent)
                {
                    return undefined;
                }
            }

            return parent;
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.processingInstructions = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].processingInstructions(name);

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String | Number name
         *    @returns Boolean
         */
        XMLList.prototype.propertyIsEnumerable = function (name)
        {
            return parseInt(name) > 0 && parseInt(name) < this._Children.length;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.text = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].text();

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns String
         */
        XMLList.prototype.toString = function ()
        {
            return ToString(this);
        };

        /**
         *
         *
         *    @returns String
         */
        XMLList.prototype.toXMLString = function ()
        {
            return ToXMLString(this);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.valueOf = function ()
        {
            return this;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @param XML Value
         *    @param isElement
         *    @returns null
         */
        XMLList.prototype.Put = function (PropertyName, Value,isChildElement)
        {
            isChildElement = isChildElement !== undefined ? isChildElement : false;
            var i = parseInt(PropertyName), r, y, l, z, parent, c, j = 0, q, t;

            if (i+"" == PropertyName)
            {
                r = ResolveValue.call(this._TargetObject);
                /* Firefox doesn't do this
                 if (r == null)
                 {
                 return null;
                 }
                 */
                if (i >= this._Children.length)
                {
                    if (r instanceof XMLList)
                    {
                        if (r.length() != 1)
                        {
                            return null;
                        }

                        r = r[0];
                    }

                    /* Firefox doesn't do this
                     if (r._Class != "element")
                     {
                     return null;
                     }
                     */
                    y = new XML();
                    y._Parent = r;
                    y._Name = this._TargetProperty;
                    y._Attributes = {};

                    if (this._TargetProperty instanceof AttributeName)
                    {
                        if (!!r && Get.call(r, y._Name).length() > 0)
                        {
                            return null;
                        }

                        y._Class = "attribute";
                    }
                    else if (!isChildElement && (this._TargetProperty == null || this._TargetProperty.localName === "*"))
                    {
                        y._Name = null;
                        y._Class = "text";
                    }
                    else
                    {
                        y._Class = "element";
                    }

                    if (y._Class != "attribute")
                    {
                        if (r)
                        {
                            j = 0;

                            if (i > 0)
                            {
                                while (j < r._Children.length-1 && r[j] !== this[i-1])
                                {
                                    ++j;
                                }
                            }
                            else
                            {
                                j = r._Children.length - 1;
                            }

                            Insert.call(r, j+1, y);
                        }

                        if (Value instanceof XMLList)
                        {
                            y._Name = Value._TargetProperty;
                        }
                        else if (Value instanceof XML)
                        {
                            y._Name = Value._Name;
                        }
                    }

                    this.Append(y);
                }

                if (!(Value instanceof XML) || Value._Class === "text" || Value._Class === "attribute")
                {
                    Value = ToString(Value);
                }

                if (this[i]._Class === "attribute")
                {
                    z = ToAttributeName(this[i]._Name);
                    this[i]._Parent.Put(z, Value);
                    this[i] = this[i]._Parent.attribute(z)[0];
                }
                else if (Value instanceof XMLList)
                {
                    //shallow copy?
                    c = Value;
                    parent = this[i]._Parent;

                    if (parent)
                    {
                        q = this[i].childIndex();
                        Replace.call(parent, q, c);
                        for (j = 0, l = c._Children.length; j < l; ++j)
                        {
                            c._Children[j] = c[j] = parent._Children[q+j];
                        }
                    }

                    if (c._Children.length === 0)
                    {
                        for (j = i + 1, l = this._Children.length; j < l; ++j)
                        {
                            this._Children[j-1] = this[j-1] = this[j]
                        }
                    }
                    else
                    {
                        for (j = this._Children.length; j > i; --j)
                        {
                            z = ToString(j + c._Children.length - 1);
                            this._Children[z] = this[z] = this[j];
                        }
                    }

                    for (j = 0, l = c._Children.length; j < l; ++j)
                    {
                        this._Children[i+j] = this[i+j] = c[j];
                    }

                }
                else if (Value instanceof XML || (",text,comment,processing-instruction").indexOf("," + this[i]._Class+",") > -1)
                {
                    parent = !!this[i] && this[i]._Parent;

                    if(parent)
                    {
                        q = this[i].childIndex();
                        Replace.call(parent, q, Value);
                        Value = parent._Children[q];
                    }

                    if (toString.call(Value) === "[object String]")
                    {
                        t = ToXML(Value);
                        t._Parent = this;
                        this._Children[i] = this[i] = t;
                    }
                    else
                    {

                    }
                }
                else
                {
                    this.Append(XMLList(Value));
                }
            }
            /* Firefox doesn't do this
             else if (this.length() <= 1)
             {
             if (this.length() === 0)
             {
             r = ResolveValueList.call(this);

             if (r == null || r.length() != 1)
             {
             return null;
             }

             this.Append(r);
             }
             else
             {
             this[0].Put(PropertyName, Value);
             }
             }*/

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @returns null
         */
        XMLList.prototype.Delete = function (PropertyName)
        {
            var i = parseInt(PropertyName), parent, q, l;

            if (i+"" == PropertyName)
            {
                if (i >= this._Children.length)
                {
                    return true;
                }

                parent = this[i]._Parent;

                if (parent)
                {
                    if (this[i]._Class = "attribute")
                    {
                        parent.Delete(ToAttributeName(this[i]._Name));
                    }
                    else
                    {
                        DeleteByIndex.call(parent, this[i].childIndex());
                    }
                }

                try{
                    this._Children.splice(PropertyName,1);
                    delete this[PropertyName];
                }catch(e){}

                for (q = i + 1, l = this._Children.length; q < l; ++q)
                {
                    this._Children[q-1] = this[q-1] = this[q];
                }
                return true;
            }
            /* Firefox won't do this
             for (q = 0, l = this._Children.length; q < l; ++q)
             {
             if (this[q]._Class === "element")
             {
             this[q].Delete(PropertyName);
             }
             }
             */
            return true;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns null
         */
        XMLList.prototype.Append = function (Value)
        {
            if (!(Value instanceof XML))
            {
                return null;
            }

            var i = this._Children.length, n = 1, j = 0;

            if (Value instanceof XMLList)
            {
                n = Value._Children.length;

                if (n == 0)
                {
                    return null;
                }

                this._TargetObject = Value._TargetObject;
                this._TargetProperty = Value._TargetProperty;

                for (;j < n; ++j)
                {
                    this._Children[i+j] = this[i+j] = Value[j];
                }
            }
            else
            {
                this._Children[i] = this[i] = Value;
            }

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns Boolean
         */
        XMLList.prototype.Equals = function (Value)
        {
            if (Value == undefined && this._Children.length === 0)
            {
                return true;
            }
            else if (Value instanceof XMLList && Value._Children.length === this._Children.length)
            {
                for (var i = 0, l = this._Children.length; i < l; ++i)
                {
                    if (!this[i].Equals(Value[i]))
                    {
                        return false;
                    }
                }
            }
            else if (this._Children.length === 1)
            {
                return this[0].Equals(Value);
            }

            return false;
        };

        /**
         *
         *
         *
         *    @access private
         *    @returns XMLList
         */
        function ResolveValueList ()
        {
            if (this._Children.length > 0)
            {
                return this;
            }

            if (this._TargetObject == null
                || this._TargetProperty == null
                || this._TargetProperty instanceof AttributeName
                || this._TargetProperty.localName === "*"
            )
            {
                return null;
            }

            var base = ResolveValue.call(this._TargetObject), target;

            if (base == null)
            {
                return null;
            }

            target = Get.call(base, this._TargetProperty);

            if (target._Children.length === 0)
            {
                if (base instanceof XMLList && base._Children.length > 1)
                {
                    return null;
                }

                base.Put(this._TargetProperty, "");

                target = Get.call(base, this._TargetProperty);
            }

            return target;
        };

        /**
         *
         *
         *    @param String | Namespace | QName prefix
         *    @param String uri
         *    @returns Namespace
         *    @throws TypeError
         */
        function Namespace (prefix, uri)
        {
            if (!(this instanceof Namespace))
            {
                return prefix && prefix instanceof Namespace
                    ? prefix
                    : new Namespace(prefix, uri);
            }

            if (uri === undefined && prefix === undefined)
            {
                this.prefix = "";
                this.uri = "";
            }
            else if (uri === undefined)
            {
                uri = prefix;
                prefix = undefined;

                if (uri instanceof Namespace)
                {
                    this.prefix = uri.prefix;
                    this.uri = uri.uri;
                }
                else if (uri instanceof QName && uri.uri !== null)
                {
                    this.uri = uri.uri;
                }
                else
                {
                    this.uri = ToString(uri);

                    if (this.uri == "")
                    {
                        this.prefix = "";
                    }
                }
            }
            else
            {
                if (uri instanceof QName)
                {
                    this.uri = uri.uri;
                }
                else
                {
                    this.uri = ToString(uri);
                }

                if (this.uri === "")
                {
                    if (prefix === undefined || ToString(prefix) === "")
                    {
                        this.prefix = "";
                    }
                    else
                    {
                        throw new TypeError("cannot define the prefix for an empty uri");
                    }
                }
                else if (prefix === undefined)
                {
                    this.prefix = undefined;
                }
                else
                {
                    this.prefix = ToString(prefix);
                }
            }
        }

        /**
         *
         *
         *    @var String
         */
        Namespace.prototype.prefix = undefined;

        /**
         *
         *
         *    @var String
         */
        Namespace.prototype.uri = undefined;

        /**
         *
         *
         *    @returns String
         */
        Namespace.prototype.toString = function ()
        {
            return this.uri;
        };

        /**
         *
         *
         *    @param Namespace | String | QName NameSpace
         *    @param String
         *    @returns QName
         */
        function QName (NameSpace, Name)
        {
            if (!(this instanceof QName))
            {
                return NameSpace instanceof QName
                    ? NameSpace
                    : new QName(NameSpace, Name);
            }

            if (Name === undefined)
            {
                Name = NameSpace;
                NameSpace = undefined;
            }

            if (Namespace instanceof QName)
            {
                if (Name === undefined)
                {
                    Name = Name.localName;
                }
            }

            Name = Name === undefined || Name === null
                ? ""
                : ToString(Name);

            if (NameSpace === undefined)
            {
                NameSpace = Name === "*" ? null : GetDefaultNamespace();
            }

            this.localName = Name;

            if (NameSpace == null)
            {
                this.uri = null;
            }
            else
            {
                NameSpace = Namespace(NameSpace);
                this.uri = NameSpace.uri;
                this._Prefix = NameSpace.prefix;
            }
        }

        /**
         *
         *
         *    @var String
         */
        QName.prototype.localName = undefined;

        /**
         *
         *
         *    @var String
         */
        QName.prototype.uri = undefined;

        /**
         *
         *
         *    @param Object InScopeNamespaces
         *    @returns Namespace
         *    @throws TypeError
         */
        function GetNamespace (q, InScopeNamespaces)
        {
            if(!q)
                return new Namespace();
            if (q.uri === null)
            {
                throw new TypeError();
            }

            InScopeNamespaces = InScopeNamespaces || {};

            var ns, p;

            for (p in InScopeNamespaces)
            {
                if (q.uri === InScopeNamespaces[p].uri)
                {
                    ns = InScopeNamespaces[p];

                    if (!!q._Prefix && q._Prefix === ns.prefix)
                    {
                        return ns;
                    }
                }
            }

            if (!ns)
            {
                ns = !!q._Prefix
                    ? new Namespace(q._Prefix, q.uri)
                    : new Namespace(q.uri);
            }

            return ns;
        };

        /**
         *
         *
         *    @returns String
         */
        QName.prototype.toString = function ()
        {
            return !!this.uri
                ? this.uri + "::" + this.localName
                : this.localName;
        };

        /**
         *
         *
         *    @param AttributeName | QName | String name
         *    @returns AttributeName
         */
        function AttributeName (name)
        {
            if (!(this instanceof AttributeName))
            {
                return name && (name instanceof AttributeName || name instanceof QName)
                    ? name
                    : new AttributeName(name);
            }

            this._Name = name instanceof QName
                ? name
                : new QName(new Namespace(GetDefaultNamespace()||undefined), name);
        }

        /**
         *
         *
         *    @var String
         */
        AttributeName.prototype.localName = undefined;

        /**
         *
         *
         *    @var String
         */
        AttributeName.prototype.uri = undefined;

        /**
         *
         *
         *    @returns String
         */
        AttributeName.prototype.toString = function ()
        {
            return "@" + (!!this._Name.uri
                        ? this._Name.uri + "::" + this._Name.localName
                        : this._Name.localName
                );
        };

        /**
         *
         *
         *
         */
        function AnyName ()
        {

        }

        /**
         *
         *
         *    @param mixed value
         *    @returns Boolean
         */
        function isXMLName (value)
        {
            if (value instanceof AttributeName)
            {
                return true;
            }

            try{
                var q = QName(value);
            }
            catch (e)
            {
                return false;
            }

            return !!q.localName && (!!q.localName.match(/^[\w\-]+$/i) || !!q.localName.match(/^[\w\-\:]+$/i));
        }

        /**
         *
         *
         *    @param mixed value
         *    @returns String
         *    @throws TypeError
         */
        function ToString (value)
        {
            var i = 0, l, s;

            if (value instanceof XMLList)
            {
                if (value.hasSimpleContent())
                {
                    s = "";

                    for (l = value.length(); i < l; ++i)
                    {
                        if (value[i]._Class != "comment" && value[i]._Class != "processing-instruction")
                        {
                            s += ToString(value[i]);
                        }
                    }

                    return s;
                }

                return ToXMLString(value);
            }
            else if (value instanceof XML)
            {
                if (value._Class === "attribute" || value._Class === "text")
                {
                    return value._Value;
                }

                if (value.hasSimpleContent())
                {
                    s = "";

                    for (l = value.length(); i < l; ++i)
                    {
                        if (value.child(i)._Class != "comment" && value.child(i)._Class != "processing-instruction")
                        {
                            s += ToString(value.child(i));
                        }
                    }

                    return s;
                }

                return ToXMLString(value);
            }
            else if (value instanceof AttributeName)
            {
                return "@" + ToString(value._Name);
            }

            return value === null || value === undefined
                ? ""
                : "" + value;
        }

        /**
         *
         *
         *    @param XML input
         *    @param Object AncestorNamespaces
         *    @param Number IndentLevel
         *    @returns String
         */
        function ToXMLString (input, AncestorNamespaces, IndentLevel)
        {
            var s = "", p = 0, temp, temp2, namespace, namespaceUnion,
                namespaceDeclarations = {}, attrAndNamespaces, prefixes, defaultSet;

            AncestorNamespaces = AncestorNamespaces || {};

            IndentLevel = Number(IndentLevel || 0);

            if (input instanceof XMLList)
            {
                temp = input.hasSimpleContent();

                temp2 = input.length();

                for (; p < temp2; ++p)
                {
                    if (p > 0)
                    {
                        s += "\r\n";
                    }

                    s += ToXMLString(input[p], AncestorNamespaces);
                }

                return s;
            }
            else if (input instanceof XML)
            {
                if (XML.prettyPrinting)
                {
                    //s += new Array(IndentLevel+1).join(" ");
                    for (; p < IndentLevel; ++p)
                    {
                        s += " ";
                    }
                }

                switch (input._Class)
                {
                    case "text":
                        return s + EscapeElementValue(XML.prettyPrinting ? trim(input._Value) : input._Value);

                    case "attribute":
                        return s + EscapeAttributeValue(input._Value);

                    case "comment":
                        return s + "<!--" + input._Value + "-->";

                    case "processing-instruction":
                        return s + "<?" + input._Name.localName + " " + input._Value + "?>";

                    default:
                        namespaceUnion = extend({}, AncestorNamespaces);

                        for (p in input._InScopeNamespaces)
                        {
                            temp = input._InScopeNamespaces[p];

                            if (!AncestorNamespaces[(temp.prefix||"")] || AncestorNamespaces[(temp.prefix||"")].uri != temp.uri)
                            {
                                namespaceUnion[(temp.prefix||"")] = namespaceDeclarations[(temp.prefix||"")] = new Namespace(temp);
                            }
                        }

                        if (!input._Parent)
                        {
                            namespaceUnion[(input._DefaultNamespace.prefix||"")] =
                                namespaceDeclarations[(input._DefaultNamespace.prefix||"")] = new Namespace(input._DefaultNamespace);
                        }
                        /*
                         //firefox doesn't do this
                         for (p in input._Attributes)
                         {
                         namespace = GetNamespace(input._Attributes[p]._Name, namespaceUnion);

                         if (namespace.prefix === undefined)
                         {
                         do {
                         namespace.prefix = !namespaceUnion[""] ? "" : newPrefix();
                         }
                         while(!!namespaceUnion[namespace.prefix]);
                         }

                         namespaceUnion[namespace.prefix] = namespaceDeclarations[namespace.prefix] = namespace;
                         }
                         */

                        s += "<";

                        namespace = GetNamespace(input._Name, namespaceDeclarations);

                        if (namespace.prefix)
                        {
                            s += namespace.prefix + ":";
                        }

                        s += input._Name ? input._Name.localName : "";

                        attrAndNamespaces = extend({}, input._Attributes, namespaceDeclarations);

                        defaultSet = false;

                        for (p in attrAndNamespaces)
                        {
                            s += " ";

                            if (attrAndNamespaces[p] instanceof XML)
                            {
                                temp = GetNamespace(attrAndNamespaces[p]._Name, AncestorNamespaces);

                                if (temp.prefix === undefined && !namespaceUnion[""])
                                {
                                    do{
                                        temp.prefix = !namespaceUnion[""] ? "" : newPrefix();
                                    }
                                    while(namespaceUnion[temp.prefix]);

                                    namespaceUnion[temp.prefix] = namespaceDeclarations[temp.prefix] = new Namespace(temp);
                                }

                                if (temp.prefix)
                                {
                                    s += temp.prefix + ":";
                                }

                                s += attrAndNamespaces[p].localName() + '="' + EscapeAttributeValue(attrAndNamespaces[p]._Value) + '"';
                            }
                            else
                            {
                                s += "xmlns";

                                if (!attrAndNamespaces[p].prefix && defaultSet)
                                {
                                    do{
                                        attrAndNamespaces[p].prefix = newPrefix();
                                    }
                                    while(!!namespaceUnion[attrAndNamespaces[p].prefix]);

                                    namespaceUnion[attrAndNamespaces[p].prefix] =
                                        namespaceDeclarations[attrAndNamespaces[p].prefix] =
                                            new Namespace(attrAndNamespaces[p]);

                                    s += ":" + attrAndNamespaces[p].prefix;
                                }
                                else if (!attrAndNamespaces[p].prefix && !defaultSet)
                                {
                                    defaultSet = true;
                                }
                                else if (attrAndNamespaces[p].prefix)
                                {
                                    s += ":" + attrAndNamespaces[p].prefix;
                                }

                                s += '="' + EscapeAttributeValue(attrAndNamespaces[p].uri) + '"';
                            }
                        }

                        temp = input._Children.length;

                        if (!temp)
                        {
                            return s + "/>";
                        }

                        s += ">";

                        temp2 = temp > 1 || (temp == 1 && input._Class !== "text");

                        names = (!!XML.prettyPrinting && !!temp2) ? IndentLevel + Number(XML.prettyIndent) : 0;

                        prefixes = !!XML.prettyPrinting && !!temp2;

                        for (p = 0; p < temp; ++p)
                        {
                            if (prefixes)
                            {
                                s += "\r\n";
                            }

                            if (input._Children[p])
                            {
                                s += ToXMLString(input._Children[p], namespaceDeclarations, names);
                            }
                        }

                        if (prefixes)
                        {
                            s += "\r\n";

                            for (p = 0; p < IndentLevel; ++p)
                            {
                                s += " ";
                            }
                        }

                        return s + "</" + (namespace.prefix ? namespace.prefix + ":" : "") + input._Name.localName + ">";
                }

                throw new TypeError();
            }
            else if (input === undefined || input === null)
            {
                throw new TypeError();
            }
            else if (toString.call(input) === "[object Object]")
            {
                return EscapeElementValue( input.valueOf().toString() );
            }

            return ToString(input);
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XML
         *    @throws SyntaxError | TypeError
         */
        function ToXML (s)
        {
            var x, div;

            if (s instanceof XMLList)
            {
                if (s.length() == 1)
                {
                    return s[0];
                }
            }
            else if (s instanceof XML)
            {
                return s;
            }
            else if ((",string,number,boolean,").indexOf("," + typeof(s)+",") > -1)
            {

                div = parse('<parent xmlns="' + GetDefaultNamespace() + '">' + s + '</parent>');

                x = ToXML(div.documentElement)

                if (x)
                {
                    if (x.length() == 0)
                    {
                        return new XML();
                    }
                    else if (x.length() == 1)
                    {
                        x.child(0)._Parent = null;
                        return x.child(0);
                    }
                }


                throw new SyntaxError("Failed to convert DOM object to XML");
            }
            else if (s.nodeType && !isNaN(s.nodeType))
            {
                return MapInfoItemToXML(s);
            }

            throw new TypeError();
        }

        /**
         *
         *
         *    @param DOMNode i
         *    @returns XML
         *    @throws TypeError
         */
        function MapInfoItemToXML (i,n)
        {
            var x = new XML(), temp, temp2, temp3, isNScheck = isNSDef, j, l, xmlChild;

            x._Parent = null;

            switch (i.nodeType)
            {
                case TEXT_NODE:
                case CDATA_SECTION_NODE:
                    x._Class = "text";
                    x._Value = "";
                    temp = i;

                    while (temp && (temp.nodeType === TEXT_NODE || temp.nodeType === CDATA_SECTION_NODE))
                    {
                        x._Value += temp.textContent || temp.text || temp.data;
                        temp = temp.nextSibling;
                        if (n && (n.n || n.n == 0))
                        {
                            ++n.n;
                        }
                    }


                    if (XML.ignoreWhitespace && !x._Value.match(/\S+/))
                    {
                        return null;
                    }

                    return x;

                    break;
                case COMMENT_NODE:
                    if (XML.ignoreComments)
                    {
                        return null;
                    }

                    x._Class = "comment";
                    x._Value = i.data || i.textContent || i.text || "";

                    return x;

                    break;
                case PROCESSING_INSTRUCTION_NODE:
                    if (XML.ignoreProcessingInstructions)
                    {
                        return null;
                    }

                    x._Class = "processing-instruction";
                    x._Name = new QName("", i.target);
                    x._Value = i.data || i.textContent || i.text || "";

                    return x;

                    break;
                case ATTRIBUTE_NODE:
                    x._Class = "attribute";

                    temp = i.nodeName.match(/(([\w\-]+):)?([\w\-]+)/);

                    if ( temp[1] )
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace(temp[2]);
                        }
                        else
                        {
                            temp3 = n;//hack for ie -- stupid ie

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == ("xmlns:" + temp[2]))
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }
                        x._DefaultNamespace = new Namespace( temp[2], temp2 );
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }
                    else
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace("");
                        }
                        else
                        {
                            temp3 = i.parentNode;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == "xmlns")
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }

                        x._DefaultNamespace = new Namespace("", temp2);
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }

                    x._Value = i.value || null;

                    return x;

                    break;
                case ELEMENT_NODE:
                    x._Class = "element";
                    temp = i.nodeName.match(/(([\w\-]+):)?([\w\-]+)/);

                    if ( temp[1] )
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace(temp[2]);
                        }
                        else
                        {
                            temp3 = i;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == ("xmlns:" + temp[2]))
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }
                        x._DefaultNamespace = new Namespace( temp[2], temp2 );
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }
                    else
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace("");
                        }
                        else
                        {
                            temp3 = i;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == "xmlns")
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }

                        x._DefaultNamespace = new Namespace("", temp2);

                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }

                    for (temp = 0, temp2 = i.attributes.length; temp < temp2; ++temp)
                    {
                        if (temp3 = isNScheck.exec(i.attributes[temp].nodeName))
                        {
                            x._InScopeNamespaces[temp3[1]] = new Namespace(temp3[1], i.attributes[temp].value);
                        }
                        else if (i.attributes[temp].nodeName === "xmlns")
                        {
                            x._InScopeNamespaces[""] = new Namespace(i.attributes[temp].value);
                        }
                        else
                        {
                            x._Attributes[i.attributes[temp].nodeName] = MapInfoItemToXML(i.attributes[temp], i);
                        }
                    }

                    j = 0;
                    xmlChild = 0;
                    temp = i.childNodes.length;

                    while (j < temp)
                    {
                        n = {n:-1};
                        if (temp3 = MapInfoItemToXML(i.childNodes[j], n))
                        {
                            //even though it is not written this way in the spec
                            //this is how it works in Firefox
                            x._Children[xmlChild] = temp3;
                            x._Children[xmlChild]._Parent = x;

                            if (temp3._Class === "text" && n.n > 0)
                            {
                                j = j + n.n;
                            }

                            ++xmlChild;
                        }

                        ++j;
                    }

                    x._Value = i.textContent || i.text || i.data || "";

                    x._Length = xmlChild;

                    return x;

                    break;
                case DOCUMENT_NODE:
                //firefox won't do this
                //return MapInfoItemToXML(document.documentElement);
                //break;
                case ENTITY_REFERENCE_NODE:
                    throw new TypeError();
                    break;
                default:
                    return null;
                    break;
            }
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XML
         *    @throws TypeError
         */
        function ToXMLList (s)
        {
            var e,x,list,i,l;

            if (s instanceof XMLList)
            {
                return s;
            }
            else if (s instanceof XML)
            {
                list = new XMLList();
                list._Children[0] = list[0] = s;
                list._TargetObject = x._Parent;
                list._TargetProperty = x._Name;

                return list;
            }
            else if ((",string,boolean,number,").indexOf("," + typeof(s)+",") === -1)
            {
                throw new TypeError();
            }

            e = parse('<parent xmlns="' + GetDefaultNamespace() + '">' + s + '</parent>');
            x = ToXML(e.documentElement);
            list = new XMLList();
            i = 0;
            l = x._Children.length;

            list._TargetObject = null;

            for (;i < l; ++i)
            {
                x._Children[i]._Parent = null;
                list._Children[i] = list[i] = x._Children[i];
            }


            return list;
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XMLList
         *    @throws TypeError
         */
        function ToAttributeName (s)
        {
            if (s === "*")
            {
                return new AttributeName(new QName(null, "*"));
            }
            else if (s instanceof QName)
            {
                return new AttributeName(s);
            }
            else if (s instanceof AttributeName)
            {
                return s;
            }

            switch (typeof(s))
            {
                case "undefined":
                case "null":
                case "boolean":
                case "number":
                    throw new TypeError();
                    break;
                case "string":
                    return new AttributeName(new QName(null, (s + "").replace(/^@/,"")));
                    break;
                case "object":
                    return new AttributeName(new QName(null, ToString(s)));
                    break;
            }
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns QName | AttributeName
         *    @throws TypeError
         */
        function ToXMLName (s)
        {
            if (s instanceof QName || s instanceof AttributeName)
            {
                return s;
            }
            else if (s === "*")
            {
                return new QName("*");
            }

            switch (typeof(s))
            {
                case "undefined":
                case "null":
                case "boolean":
                case "number":
                    throw new TypeError();
                    break;
                case "string":
                    if (s.charAt(0) === "@")
                    {
                        return ToAttributeName( s.substr(0) );
                    }

                    return new QName(s);

                    break;
                case "object":
                    return ToXMLName( ToString(s) );
                    break;
            }
        }

        /**
         *
         *
         *    @returns String
         */
        function GetDefaultNamespace ()
        {
            return !!defaultNamespace && defaultNamespace.uri || "";
        }

        /**
         *
         *
         *    @param String s
         *    @returns String
         */
        function EscapeElementValue (s)
        {
            return ((s||"")+"").replace(/./g, function (c)
            {
                switch (c)
                {
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    default:
                        return c;
                }
            });
        }

        /**
         *
         *
         *
         *    @param String s
         *    @returns String
         */
        function EscapeAttributeValue (s)
        {
            return ((s||"")+"").replace(/./g, function (c)
            {
                switch (c)
                {
                    case '"':
                        return "&quot;";
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    case "\r":
                        return "&#xA;";
                    case "\n":
                        return "&#xD;";
                    case "\t":
                        return "&#x9;";
                    default:
                        return c;
                }
            });
        }

        /**
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function Get (PropertyName)
        {
            if (this instanceof XMLList)
            {
                return GetList.call(this, PropertyName);
            }

            if (parseInt(PropertyName)+"" == PropertyName)
            {
                return GetList.call(ToXMLList(this), PropertyName );
            }

            var n = ToXMLName(PropertyName),
                list = new XMLList(), p, l;

            list._TargetObject = this;
            list._TargetProperty = n;

            if (n instanceof AttributeName)
            {
                for (p in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[p]._Name.localName)
                        &&
                        (n._Name.uri == null || n._Name.uri === this._Attributes[p]._Name.uri)
                    )
                    {
                        list.Append(this._Attributes[p]);
                    }
                }
            }
            else
            {
                for (p = 0, l = this._Children.length; p < l; ++p)
                {
                    if (
                        (n.localName === "*" || (this._Children[p]._Class === "element" && this._Children[p]._Name.localName === n.localName))
                        &&
                        (n.uri == null || (this._Children[p]._Class === "element" && n.uri === this._Children[p]._Name.uri))
                    )
                    {
                        list.Append(this._Children[p]);
                    }
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName P
         *    @returns Boolean
         */
        function HasProperty (P)
        {
            if (this instanceof XMLList)
            {
                return HasPropertyList.call(this, P);
            }

            if (parseInt(P) == P)
            {
                return P == "0";
            }

            var n = ToXMLName(P), k, l;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (
                            n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName
                        ) &&
                        (
                            n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri
                        )
                    )
                    {
                        return true;
                    }
                }

                return false;
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName === n.localName))
                    &&
                    (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                )
                {
                    return true;
                }
            }

            return false;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns Boolean
         *    @throws TypeError
         */
        function DeleteByIndex (PropertyName)
        {
            var i = parseInt(PropertyName);//, q = i + 1, l = this._Children.length;

            if (i == PropertyName)
            {
                if (!!this._Children[i])
                {
                    this._Children[i]._Parent = null;

                    this._Children[i] = null;

                    this._Children.splice(i, 1);

                    /*
                     for (;q < l;++q)
                     {
                     this._Children[q-1] = this._Children[q];
                     }
                     */
                }

                return true;
            }

            throw new TypeError();
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XML
         */
        function DeepCopy ()
        {
            if (this instanceof XMLList)
            {
                return DeepCopyList.call(this);
            }

            var y = new XML(), i, l;//, c, t;

            y._Class = this._Class;
            y._Name = this._Name;
            y._DefaultNamespace = this._DefaultNamespace ? new Namespace(this._DefaultNamespace) : null;
            y._Value = this._Value;
            y._Parent = null;

            for (i in this._InScopeNamespaces)
            {
                y._InScopeNamespaces[i] = new Namespace(this._InScopeNamespaces.prefix, this._InScopeNamespaces.uri);
            }

            for (l in this._Attributes)
            {
                //y._Attributes[i] = arguments.callee.call(this._Attributes[i]);
                //not part of the spec
                y._Attributes[i] = this._Attributes[l].copy();
                y._Attributes[i]._Parent = y;
            }

            for (i = 0, l = this._Children.length; i < l; ++i)
            {
                y._Children[i] = this._Children[i].copy();
                y._Children[i]._Parent = y;
            }

            return y;
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XML
         */
        function ResolveValue ()
        {
            if (this instanceof XMLList)
            {
                return ResolveValueList.call(this);
            }
            return this instanceof XML ? this : null;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function Descendants (PropertyName)
        {
            if (this instanceof XMLList)
            {
                return DescendantsList.call(this, PropertyName);
            }

            var n = ToXMLName(PropertyName),
                list = new XMLList(),
                k, l, dq;

            list._TargetObject = null;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName)
                        &&
                        (n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri)
                    )
                    {
                        list.Append(this._Attributes[k]);
                    }
                }
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName === n.localName))
                    &&
                    (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                )
                {
                    list.Append(this._Children[k]);
                }

                dq = this._Children[k].descendants(n);

                if (dq.length() > 0)
                {
                    list.Append(dq);
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML Value
         *    @returns null
         *    @throws TypeError | Error
         */
        function Insert (PropertyName, Value)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            var i = parseInt(PropertyName), n, j;

            if (i+"" != PropertyName)
            {
                throw new TypeError("'" + i + "' != '" + PropertyName + "'");
            }

            if (Value === this || indexOf("," + this, Value.descendants("*")) > -1)
            {
                throw new Error();
            }

            n = Value.length();

            for (j = this._Children.length - 1; j >= i; --j)
            {
                this._Children[ j + n ] = this._Children[j];
            }


            if (Value instanceof XMLList)
            {
                for (j = 0; j < n; ++j)
                {
                    Value[j]._Parent = this;
                    this._Children[i + j] = Value[j];
                }
            }
            else
            {
                Replace.call(this, i, Value);
            }

            return null;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML Value
         *    @returns null
         *    @throws TypeError
         */
        function Replace (PropertyName, Value)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var i = parseInt(PropertyName), t;

            if (i+"" != PropertyName)
            {
                throw new TypeError("'" + i + "' != '" + PropertyName + "'");
            }

            if (i >= this._Children.length)
            {
                PropertyName = this._Children.length;
            }

            if (Value instanceof XMLList)
            {
                DeleteByIndex.call(this, PropertyName);
                Insert.call(this, PropertyName, Value);
            }
            else if (Value instanceof XML
                && Value._Class === "element"
                && (",element,comment,processing-instruction,text").indexOf("," + Value._Class + ",") > -1
            )
            {
                Value._Parent = this;

                if (this._Children[PropertyName])
                {
                    this._Children[PropertyName]._Parent = null;
                }

                this._Children[PropertyName] = Value;
            }
            else
            {
                t = new XML();
                t._Parent = this;
                t._Value = ToString(Value);

                if (this._Children[PropertyName])
                {
                    this._Children[PropertyName]._Parent = null;
                }

                this._Children[PropertyName] = t;
            }
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Namespace NameSpace
         *    @returns null
         */
        function AddInScopeNamespace (NameSpace)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var match = null, p;

            if (NameSpace.prefix == "" && this._Name.uri == "")
            {
                return null;
            }

            for (p in this._InScopeNamespaces)
            {
                if (NameSpace.prefix === this._InScopeNamespaces[p].prefix)
                {
                    match = this._InScopeNamespaces[p];
                }
            }

            if (match && match.uri != NameSpace.uri)
            {
                this._InScopeNamespaces[match.prefix] = null;
                try{
                    delete this._InScopeNamespaces[match.prefix];
                }catch(e){}
            }

            this._InScopeNamespaces[NameSpace.prefix] = NameSpace;

            if (this._Name.prefix === NameSpace.prefix)
            {
                this._Name.prefix = undefined;
            }

            for (p in this._Attributes)
            {
                if (this._Attributes[p]._Name.prefix = NameSpace.prefix)
                {
                    this._Attributes[p]._Name.prefix = undefined;
                }
            }

            //do this in order to ensure namespace integrity
            /*match = parse(this.toXMLString());
             this._Node = !!this._Node.parentNode
             ? this._Node.parentNode.replaceChild(match.documentElement, this._Node)
             : match;*/
        }

        /**
         *
         *
         *    @access private
         *    @param String | Number name
         *    @returns Boolean
         */
        function HasPropertyList (name)
        {
            if (ToString( parseInt(name) ) === name)
            {
                return parseInt(name) < this._Children.length;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this[i]._Class === "element" && this[i].hasOwnProperty(name))
                {
                    return true;
                }
            }

            return false;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @returns XMLList
         */
        function GetList (PropertyName)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                return this[PropertyName];
            }

            var list = new XMLList(), i = 0, l = this._Children.length, temp;
            list._TargetObject = this;
            list._TargetProperty = PropertyName;

            for (;i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    temp = Get.call(this._Children[i], PropertyName);

                    if (temp._Children.length > 0)
                    {
                        list.Append(temp);
                    }
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XMLList
         */
        function DeepCopyList ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;

            list._TargetObject = this._TargetObject;
            list._TargetProperty = this._TargetProperty;
            list._Class = this._Class;
            list._Value = this._Value;

            for (;i < l; ++i)
            {
                list.Append(DeepCopy.call(this[i]));
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function DescendantsList (PropertyName)
        {
            var list = new XMLList(), i = 0, l = this._Children.length, temp;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    if ((temp = Descendants.call(this[i], "*")) && temp.length() > 0)
                    {
                        list.Append(temp);
                    }
                }
            }

            return list;
        }

        /**
         *    http://blog.stevenlevithan.com/archives/faster-trim-javascript
         *
         *
         *    @param String s
         *    @returns String
         */
        function trim (str)
        {
            if(!str)
                return str;
            var    str = str.replace(/^\s\s*/, ""),
                ws = /\s/,
                i = str.length;
            while (ws.test(str.charAt(--i)));
            return str.slice(0, i + 1);
        }

        /**
         *    Generates a prefix for a QName that is not already
         *    a property of the optional argument
         *
         *    @param Object prefixes
         *    @returns String
         */
        function newPrefix (prefixes)
        {
            prefixes = prefixes || {};

            var num = Math.random()
                .toString()
                .substr(2)
                .replace(/.{2}/g, function (a)
                {
                    a = Number(a);
                    return (a > 90 ? 90 : (a < 65 ? 65 : a)) + "";
                });

            num = String.fromCharCode(
                Number(num.substr(0, 2)) & 0xFF,
                Number(num.substr(2, 2)) & 0xFF,
                Number(num.substr(4, 2)) & 0xFF,
                Number(num.substr(6, 2)) & 0xFF,
                Number(num.substr(8, 2)) & 0xFF,
                Number(num.substr(10, 2)) & 0xFF
            ).toLowerCase();

            while (num in prefixes)
            {
                num = arguments.callee(prefixes);
            }

            return num;
        }

        /**
         *
         *
         *    @param String str
         *    @returns DOMNode
         *    @throws SyntaxError
         */
        function parse (str)
        {
            var xmlDoc, success = true;

            if (isActiveXSupported("Microsoft.XMLDOM")) //Internet Explorer
            {
                try{
                    xmlDoc                      = new ActiveXObject("Microsoft.XMLDOM");
                    xmlDoc.async                = 'false';
                    xmlDoc.preserveWhiteSpace   = true;
                    xmlDoc.resolveExternals     = false;
                    xmlDoc.validateOnParse         = false;
                    xmlDoc.setProperty('ProhibitDTD', false);
                    success = xmlDoc.loadXML(str);
                }catch(e){}
            }
            else
            {
                try{//Firefox, Mozilla, Opera, etc.
                    xmlDoc = new DOMParser();
                    xmlDoc = xmlDoc.parseFromString(str, "text/xml");
                }catch(e){}
            }

            if (!success || !xmlDoc || xmlDoc.documentElement.nodeName == "parsererror")
            {
                throw new SyntaxError(!!xmlDoc && xmlDoc.documentElement.childNodes[0].nodeValue);
            }

            return xmlDoc;
        }

        /**
         *
         *
         *    @param Object obj
         *    @returns Number
         */
        function count (obj)
        {
            if ("__count__" in obj)
            {
                return obj.__count__;
            }

            var i = 0, k;

            for (k in obj)
            {
                if (obj.hasOwnProperty(k))
                {
                    ++i;
                }
            }

            return i;
        }

        /**
         *
         *
         *    @param Object obj
         *    @param XMLList list
         *    @returns Number
         */
        function indexOf (obj, list)
        {
            for (var i = 0, l = list.length(); i < l; ++i)
            {
                if (list[i].Equals(obj))
                {
                    return i;
                }
            }

            return -1;
        }

        /**
         *
         *
         *    @param mixed obj
         *    @param mixed ...
         *    @returns mixed
         */
        function extend (obj)
        {
            for (var p, i = 1, l = arguments.length; i < l; ++i)
            {
                for (p in arguments[i])
                {
                    obj[p] = arguments[i][p];
                }
            }

            return obj;
        }

        /**
         *
         *
         *
         */
        function createDocumentFrom (xml)
        {
            return parse(xml.length() == 1 ? xml.toXMLString() : "<x>" + xml.toXMLString() + "</x>");
        }

        /**
         *
         *
         *
         */
        function xmlToDomNode (xml)
        {
            switch (xml.nodeKind())
            {
                case "element":
                    return createDocumentFrom(xml).documentElement;

                case "text":
                    return xmlDoc.createTextNode(xml.toString());

                case "comment":
                    return xmlDoc.createComment(xml.toString().slice(4, -3));

                case "processing-instruction":
                    return xmlDoc.createProcessingInstruction(
                        xml.localName(),
                        xml.toString().slice(2, -2).replace(piName, "")
                    );

                case "attribute":
                    return createAttributeNS(xml);
            }
            return null;
        }

        function adoptNode (doc, node)
        {
            if (!!doc.adoptNode)
            {
                return doc.adoptNode(node);
            }

            var b = doc.documentElement || doc.body;
            return b.removeChild(b.appendChild(node));
        }

        function evaluate (doc, expr, xml)
        {
            var res, l, n = "";

            if (!!doc.evaluate)
            {
                res = doc.evaluate(
                    expr,
                    doc,
                    doc.createNSResolver(doc),
                    XPathResult.ORDERED_NODE_ITERATOR_TYPE,
                    null
                );

                l = [];

                while(n = res.iterateNext())
                {
                    l[l.length] = n;
                }

                return l;
            }

            if ("setProperty" in doc){

                res = allNamespaces(xml);

                if (count(res))
                {
                    for (l in res)
                    {
                        n += " xmlns:" + l + '="' + EscapeAttributeValue(res[l]) + '"';
                    }

                    doc.setProperty('SelectionNamespaces', n.substr(1));
                }

                doc.setProperty("SelectionLanguage", "XPath");
            }

            return isActiveXSupported("Microsoft.XMLDOM") && doc.selectNodes(expr);
        }

        function isActiveXSupported(type) {
            try {
                new ActiveXObject(type);
                return true;
            } catch (e) {
                return false;
            }
        }

        function allNamespaces (xml, un)
        {
            var ns = un || {},
                i = 0,
                c = xml.children(),
                l = c.length(),
                n = un == undefined
                    ? inscope(xml)
                    : xml._InScopeNamespaces,
                p;

            for (;i < l; ++i)
            {
                ns = arguments.callee(c[i], ns);
            }

            for (p in n)
            {
                if (n[p].prefix)
                {
                    ns[n[p].prefix] = n[p].uri;
                }
            }

            return ns;
        }

        function inscope (xml)
        {
            var ns = {},
                i = 0,
                n = xml.inScopeNamespaces(),
                l = n.length;

            for (;i < l; ++i)
            {
                if (n[i].prefix)
                {
                    ns[n[i].prefix] = n[i].uri;
                }
            }

            return ns;
        }

        function createAttributeNS (xml)
        {
            var ns = xml.namespace(),
                node = !!xmlDoc.createAttributeNS
                    ? xmlDoc.createAttributeNS(ns.uri, xml.localName())
                    : xmlDoc.createAttribute((ns.prefix ? ns.prefix + ":" : "" ) + xml.localName());

            node.nodeValue = xml.toString();
            return node;
        }

        function transform (xml, style, params)
        {
            var xsl, res, i = 0, l = (params||[]).length;

            if (!window.XSLTProcessor)
            {
                //TODO: Need to create a way to set parameters on an IE stylesheet
                //XSLProcessor
                //http://msdn.microsoft.com/en-us/library/ms757015%28v=VS.85%29.aspx
                //http://msdn.microsoft.com/en-us/library/ms763679%28VS.85%29.aspx
                //http://msdn.microsoft.com/en-us/library/ms754594%28v=VS.85%29.aspx

                res = createDocumentFrom(xml).transformNode(createDocumentFrom(style));

                return !!res && ToXML(res) || null;
            }

            xsl = new XSLTProcessor();

            xsl.importStyleSheet(createDocumentFrom(style));

            for (; i < l; ++i)
            {
                res = params[i];
                xsl.setParameter(res.namespaceURI, res.localName, res.value);
            }

            res = xsl.transformToDocument(createDocumentFrom(doc))

            return !!res && ToXML(res) || null;
        }

        for (p in XML.prototype)
        {
            defaultXMLPrototype += p + ",";
        }

        for (p in XMLList.prototype)
        {
            defaultXMLListPrototype += p + ",";
        }

        /**
         *
         *
         *
         */
        window.XML              = XML;
        window.XMLList          = XMLList;
        window.QName            = QName;
        window.Namespace        = Namespace;
        window.isXMLName        = isXMLName;
        window.AttributeName    = AttributeName;

    })();
}

/***** xregexp.js *****/

/*!
 * XRegExp v2.0.0
 * (c) 2007-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 */

/**
 * XRegExp provides augmented, extensible JavaScript regular expressions. You get new syntax,
 * flags, and methods beyond what browsers support natively. XRegExp is also a regex utility belt
 * with tools to make your client-side grepping simpler and more powerful, while freeing you from
 * worrying about pesky cross-browser inconsistencies and the dubious `lastIndex` property. See
 * XRegExp's documentation (http://xregexp.com/) for more details.
 * @module xregexp
 * @requires N/A
 */
var XRegExp;

// Avoid running twice; that would reset tokens and could break references to native globals
XRegExp = XRegExp || (function (undef) {
    "use strict";

/*--------------------------------------
 *  Private variables
 *------------------------------------*/

    var self,
        addToken,
        add,

// Optional features; can be installed and uninstalled
        features = {
            natives: false,
            extensibility: false
        },

// Store native methods to use and restore ("native" is an ES3 reserved keyword)
        nativ = {
            exec: RegExp.prototype.exec,
            test: RegExp.prototype.test,
            match: String.prototype.match,
            replace: String.prototype.replace,
            split: String.prototype.split
        },

// Storage for fixed/extended native methods
        fixed = {},

// Storage for cached regexes
        cache = {},

// Storage for addon tokens
        tokens = [],

// Token scopes
        defaultScope = "default",
        classScope = "class",

// Regexes that match native regex syntax
        nativeTokens = {
            // Any native multicharacter token in default scope (includes octals, excludes character classes)
            "default": /^(?:\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9]\d*|x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|c[A-Za-z]|[\s\S])|\(\?[:=!]|[?*+]\?|{\d+(?:,\d*)?}\??)/,
            // Any native multicharacter token in character class scope (includes octals)
            "class": /^(?:\\(?:[0-3][0-7]{0,2}|[4-7][0-7]?|x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|c[A-Za-z]|[\s\S]))/
        },

// Any backreference in replacement strings
        replacementToken = /\$(?:{([\w$]+)}|(\d\d?|[\s\S]))/g,

// Any character with a later instance in the string
        duplicateFlags = /([\s\S])(?=[\s\S]*\1)/g,

// Any greedy/lazy quantifier
        quantifier = /^(?:[?*+]|{\d+(?:,\d*)?})\??/,

// Check for correct `exec` handling of nonparticipating capturing groups
        compliantExecNpcg = nativ.exec.call(/()??/, "")[1] === undef,

// Check for flag y support (Firefox 3+)
        hasNativeY = RegExp.prototype.sticky !== undef,

// Used to kill infinite recursion during XRegExp construction
        isInsideConstructor = false,

// Storage for known flags, including addon flags
        registeredFlags = "gim" + (hasNativeY ? "y" : "");

/*--------------------------------------
 *  Private helper functions
 *------------------------------------*/

/**
 * Attaches XRegExp.prototype properties and named capture supporting data to a regex object.
 * @private
 * @param {RegExp} regex Regex to augment.
 * @param {Array} captureNames Array with capture names, or null.
 * @param {Boolean} [isNative] Whether the regex was created by `RegExp` rather than `XRegExp`.
 * @returns {RegExp} Augmented regex.
 */
    function augment(regex, captureNames, isNative) {
        var p;
        // Can't auto-inherit these since the XRegExp constructor returns a nonprimitive value
        for (p in self.prototype) {
            if (self.prototype.hasOwnProperty(p)) {
                regex[p] = self.prototype[p];
            }
        }
        regex.xregexp = {captureNames: captureNames, isNative: !!isNative};
        return regex;
    }

/**
 * Returns native `RegExp` flags used by a regex object.
 * @private
 * @param {RegExp} regex Regex to check.
 * @returns {String} Native flags in use.
 */
    function getNativeFlags(regex) {
        //return nativ.exec.call(/\/([a-z]*)$/i, String(regex))[1];
        return (regex.global     ? "g" : "") +
               (regex.ignoreCase ? "i" : "") +
               (regex.multiline  ? "m" : "") +
               (regex.extended   ? "x" : "") + // Proposed for ES6, included in AS3
               (regex.sticky     ? "y" : ""); // Proposed for ES6, included in Firefox 3+
    }

/**
 * Copies a regex object while preserving special properties for named capture and augmenting with
 * `XRegExp.prototype` methods. The copy has a fresh `lastIndex` property (set to zero). Allows
 * adding and removing flags while copying the regex.
 * @private
 * @param {RegExp} regex Regex to copy.
 * @param {String} [addFlags] Flags to be added while copying the regex.
 * @param {String} [removeFlags] Flags to be removed while copying the regex.
 * @returns {RegExp} Copy of the provided regex, possibly with modified flags.
 */
    function copy(regex, addFlags, removeFlags) {
        if (!self.isRegExp(regex)) {
            throw new TypeError("type RegExp expected");
        }
        var flags = nativ.replace.call(getNativeFlags(regex) + (addFlags || ""), duplicateFlags, "");
        if (removeFlags) {
            // Would need to escape `removeFlags` if this was public
            flags = nativ.replace.call(flags, new RegExp("[" + removeFlags + "]+", "g"), "");
        }
        if (regex.xregexp && !regex.xregexp.isNative) {
            // Compiling the current (rather than precompilation) source preserves the effects of nonnative source flags
            regex = augment(self(regex.source, flags),
                            regex.xregexp.captureNames ? regex.xregexp.captureNames.slice(0) : null);
        } else {
            // Augment with `XRegExp.prototype` methods, but use native `RegExp` (avoid searching for special tokens)
            regex = augment(new RegExp(regex.source, flags), null, true);
        }
        return regex;
    }

/*
 * Returns the last index at which a given value can be found in an array, or `-1` if it's not
 * present. The array is searched backwards.
 * @private
 * @param {Array} array Array to search.
 * @param {*} value Value to locate in the array.
 * @returns {Number} Last zero-based index at which the item is found, or -1.
 */
    function lastIndexOf(array, value) {
        var i = array.length;
        if (Array.prototype.lastIndexOf) {
            return array.lastIndexOf(value); // Use the native method if available
        }
        while (i--) {
            if (array[i] === value) {
                return i;
            }
        }
        return -1;
    }

/**
 * Determines whether an object is of the specified type.
 * @private
 * @param {*} value Object to check.
 * @param {String} type Type to check for, in lowercase.
 * @returns {Boolean} Whether the object matches the type.
 */
    function isType(value, type) {
        return Object.prototype.toString.call(value).toLowerCase() === "[object " + type + "]";
    }

/**
 * Prepares an options object from the given value.
 * @private
 * @param {String|Object} value Value to convert to an options object.
 * @returns {Object} Options object.
 */
    function prepareOptions(value) {
        value = value || {};
        if (value === "all" || value.all) {
            value = {natives: true, extensibility: true};
        } else if (isType(value, "string")) {
            value = self.forEach(value, /[^\s,]+/, function (m) {
                this[m] = true;
            }, {});
        }
        return value;
    }

/**
 * Runs built-in/custom tokens in reverse insertion order, until a match is found.
 * @private
 * @param {String} pattern Original pattern from which an XRegExp object is being built.
 * @param {Number} pos Position to search for tokens within `pattern`.
 * @param {Number} scope Current regex scope.
 * @param {Object} context Context object assigned to token handler functions.
 * @returns {Object} Object with properties `output` (the substitution string returned by the
 *   successful token handler) and `match` (the token's match array), or null.
 */
    function runTokens(pattern, pos, scope, context) {
        var i = tokens.length,
            result = null,
            match,
            t;
        // Protect against constructing XRegExps within token handler and trigger functions
        isInsideConstructor = true;
        // Must reset `isInsideConstructor`, even if a `trigger` or `handler` throws
        try {
            while (i--) { // Run in reverse order
                t = tokens[i];
                if ((t.scope === "all" || t.scope === scope) && (!t.trigger || t.trigger.call(context))) {
                    t.pattern.lastIndex = pos;
                    match = fixed.exec.call(t.pattern, pattern); // Fixed `exec` here allows use of named backreferences, etc.
                    if (match && match.index === pos) {
                        result = {
                            output: t.handler.call(context, match, scope),
                            match: match
                        };
                        break;
                    }
                }
            }
        } catch (err) {
            throw err;
        } finally {
            isInsideConstructor = false;
        }
        return result;
    }

/**
 * Enables or disables XRegExp syntax and flag extensibility.
 * @private
 * @param {Boolean} on `true` to enable; `false` to disable.
 */
    function setExtensibility(on) {
        self.addToken = addToken[on ? "on" : "off"];
        features.extensibility = on;
    }

/**
 * Enables or disables native method overrides.
 * @private
 * @param {Boolean} on `true` to enable; `false` to disable.
 */
    function setNatives(on) {
        RegExp.prototype.exec = (on ? fixed : nativ).exec;
        RegExp.prototype.test = (on ? fixed : nativ).test;
        String.prototype.match = (on ? fixed : nativ).match;
        String.prototype.replace = (on ? fixed : nativ).replace;
        String.prototype.split = (on ? fixed : nativ).split;
        features.natives = on;
    }

/*--------------------------------------
 *  Constructor
 *------------------------------------*/

/**
 * Creates an extended regular expression object for matching text with a pattern. Differs from a
 * native regular expression in that additional syntax and flags are supported. The returned object
 * is in fact a native `RegExp` and works with all native methods.
 * @class XRegExp
 * @constructor
 * @param {String|RegExp} pattern Regex pattern string, or an existing `RegExp` object to copy.
 * @param {String} [flags] Any combination of flags:
 *   <li>`g` - global
 *   <li>`i` - ignore case
 *   <li>`m` - multiline anchors
 *   <li>`n` - explicit capture
 *   <li>`s` - dot matches all (aka singleline)
 *   <li>`x` - free-spacing and line comments (aka extended)
 *   <li>`y` - sticky (Firefox 3+ only)
 *   Flags cannot be provided when constructing one `RegExp` from another.
 * @returns {RegExp} Extended regular expression object.
 * @example
 *
 * // With named capture and flag x
 * date = XRegExp('(?<year>  [0-9]{4}) -?  # year  \n\
 *                 (?<month> [0-9]{2}) -?  # month \n\
 *                 (?<day>   [0-9]{2})     # day   ', 'x');
 *
 * // Passing a regex object to copy it. The copy maintains special properties for named capture,
 * // is augmented with `XRegExp.prototype` methods, and has a fresh `lastIndex` property (set to
 * // zero). Native regexes are not recompiled using XRegExp syntax.
 * XRegExp(/regex/);
 */
    self = function (pattern, flags) {
        if (self.isRegExp(pattern)) {
            if (flags !== undef) {
                throw new TypeError("can't supply flags when constructing one RegExp from another");
            }
            return copy(pattern);
        }
        // Tokens become part of the regex construction process, so protect against infinite recursion
        // when an XRegExp is constructed within a token handler function
        if (isInsideConstructor) {
            throw new Error("can't call the XRegExp constructor within token definition functions");
        }

        var output = [],
            scope = defaultScope,
            tokenContext = {
                hasNamedCapture: false,
                captureNames: [],
                hasFlag: function (flag) {
                    return flags.indexOf(flag) > -1;
                }
            },
            pos = 0,
            tokenResult,
            match,
            chr;
        pattern = pattern === undef ? "" : String(pattern);
        flags = flags === undef ? "" : String(flags);

        if (nativ.match.call(flags, duplicateFlags)) { // Don't use test/exec because they would update lastIndex
            throw new SyntaxError("invalid duplicate regular expression flag");
        }
        // Strip/apply leading mode modifier with any combination of flags except g or y: (?imnsx)
        pattern = nativ.replace.call(pattern, /^\(\?([\w$]+)\)/, function ($0, $1) {
            if (nativ.test.call(/[gy]/, $1)) {
                throw new SyntaxError("can't use flag g or y in mode modifier");
            }
            flags = nativ.replace.call(flags + $1, duplicateFlags, "");
            return "";
        });
        self.forEach(flags, /[\s\S]/, function (m) {
            if (registeredFlags.indexOf(m[0]) < 0) {
                throw new SyntaxError("invalid regular expression flag " + m[0]);
            }
        });

        while (pos < pattern.length) {
            // Check for custom tokens at the current position
            tokenResult = runTokens(pattern, pos, scope, tokenContext);
            if (tokenResult) {
                output.push(tokenResult.output);
                pos += (tokenResult.match[0].length || 1);
            } else {
                // Check for native tokens (except character classes) at the current position
                match = nativ.exec.call(nativeTokens[scope], pattern.slice(pos));
                if (match) {
                    output.push(match[0]);
                    pos += match[0].length;
                } else {
                    chr = pattern.charAt(pos);
                    if (chr === "[") {
                        scope = classScope;
                    } else if (chr === "]") {
                        scope = defaultScope;
                    }
                    // Advance position by one character
                    output.push(chr);
                    ++pos;
                }
            }
        }

        return augment(new RegExp(output.join(""), nativ.replace.call(flags, /[^gimy]+/g, "")),
                       tokenContext.hasNamedCapture ? tokenContext.captureNames : null);
    };

/*--------------------------------------
 *  Public methods/properties
 *------------------------------------*/

// Installed and uninstalled states for `XRegExp.addToken`
    addToken = {
        on: function (regex, handler, options) {
            options = options || {};
            if (regex) {
                tokens.push({
                    pattern: copy(regex, "g" + (hasNativeY ? "y" : "")),
                    handler: handler,
                    scope: options.scope || defaultScope,
                    trigger: options.trigger || null
                });
            }
            // Providing `customFlags` with null `regex` and `handler` allows adding flags that do
            // nothing, but don't throw an error
            if (options.customFlags) {
                registeredFlags = nativ.replace.call(registeredFlags + options.customFlags, duplicateFlags, "");
            }
        },
        off: function () {
            throw new Error("extensibility must be installed before using addToken");
        }
    };

/**
 * Extends or changes XRegExp syntax and allows custom flags. This is used internally and can be
 * used to create XRegExp addons. `XRegExp.install('extensibility')` must be run before calling
 * this function, or an error is thrown. If more than one token can match the same string, the last
 * added wins.
 * @memberOf XRegExp
 * @param {RegExp} regex Regex object that matches the new token.
 * @param {Function} handler Function that returns a new pattern string (using native regex syntax)
 *   to replace the matched token within all future XRegExp regexes. Has access to persistent
 *   properties of the regex being built, through `this`. Invoked with two arguments:
 *   <li>The match array, with named backreference properties.
 *   <li>The regex scope where the match was found.
 * @param {Object} [options] Options object with optional properties:
 *   <li>`scope` {String} Scopes where the token applies: 'default', 'class', or 'all'.
 *   <li>`trigger` {Function} Function that returns `true` when the token should be applied; e.g.,
 *     if a flag is set. If `false` is returned, the matched string can be matched by other tokens.
 *     Has access to persistent properties of the regex being built, through `this` (including
 *     function `this.hasFlag`).
 *   <li>`customFlags` {String} Nonnative flags used by the token's handler or trigger functions.
 *     Prevents XRegExp from throwing an invalid flag error when the specified flags are used.
 * @example
 *
 * // Basic usage: Adds \a for ALERT character
 * XRegExp.addToken(
 *   /\\a/,
 *   function () {return '\\x07';},
 *   {scope: 'all'}
 * );
 * XRegExp('\\a[\\a-\\n]+').test('\x07\n\x07'); // -> true
 */
    self.addToken = addToken.off;

/**
 * Caches and returns the result of calling `XRegExp(pattern, flags)`. On any subsequent call with
 * the same pattern and flag combination, the cached copy is returned.
 * @memberOf XRegExp
 * @param {String} pattern Regex pattern string.
 * @param {String} [flags] Any combination of XRegExp flags.
 * @returns {RegExp} Cached XRegExp object.
 * @example
 *
 * while (match = XRegExp.cache('.', 'gs').exec(str)) {
 *   // The regex is compiled once only
 * }
 */
    self.cache = function (pattern, flags) {
        var key = pattern + "/" + (flags || "");
        return cache[key] || (cache[key] = self(pattern, flags));
    };

/**
 * Escapes any regular expression metacharacters, for use when matching literal strings. The result
 * can safely be used at any point within a regex that uses any flags.
 * @memberOf XRegExp
 * @param {String} str String to escape.
 * @returns {String} String with regex metacharacters escaped.
 * @example
 *
 * XRegExp.escape('Escaped? <.>');
 * // -> 'Escaped\?\ <\.>'
 */
    self.escape = function (str) {
        return nativ.replace.call(str, /[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
    };

/**
 * Executes a regex search in a specified string. Returns a match array or `null`. If the provided
 * regex uses named capture, named backreference properties are included on the match array.
 * Optional `pos` and `sticky` arguments specify the search start position, and whether the match
 * must start at the specified position only. The `lastIndex` property of the provided regex is not
 * used, but is updated for compatibility. Also fixes browser bugs compared to the native
 * `RegExp.prototype.exec` and can be used reliably cross-browser.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {RegExp} regex Regex to search with.
 * @param {Number} [pos=0] Zero-based index at which to start the search.
 * @param {Boolean|String} [sticky=false] Whether the match must start at the specified position
 *   only. The string `'sticky'` is accepted as an alternative to `true`.
 * @returns {Array} Match array with named backreference properties, or null.
 * @example
 *
 * // Basic use, with named backreference
 * var match = XRegExp.exec('U+2620', XRegExp('U\\+(?<hex>[0-9A-F]{4})'));
 * match.hex; // -> '2620'
 *
 * // With pos and sticky, in a loop
 * var pos = 2, result = [], match;
 * while (match = XRegExp.exec('<1><2><3><4>5<6>', /<(\d)>/, pos, 'sticky')) {
 *   result.push(match[1]);
 *   pos = match.index + match[0].length;
 * }
 * // result -> ['2', '3', '4']
 */
    self.exec = function (str, regex, pos, sticky) {
        var r2 = copy(regex, "g" + (sticky && hasNativeY ? "y" : ""), (sticky === false ? "y" : "")),
            match;
        r2.lastIndex = pos = pos || 0;
        match = fixed.exec.call(r2, str); // Fixed `exec` required for `lastIndex` fix, etc.
        if (sticky && match && match.index !== pos) {
            match = null;
        }
        if (regex.global) {
            regex.lastIndex = match ? r2.lastIndex : 0;
        }
        return match;
    };

/**
 * Executes a provided function once per regex match.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {RegExp} regex Regex to search with.
 * @param {Function} callback Function to execute for each match. Invoked with four arguments:
 *   <li>The match array, with named backreference properties.
 *   <li>The zero-based match index.
 *   <li>The string being traversed.
 *   <li>The regex object being used to traverse the string.
 * @param {*} [context] Object to use as `this` when executing `callback`.
 * @returns {*} Provided `context` object.
 * @example
 *
 * // Extracts every other digit from a string
 * XRegExp.forEach('1a2345', /\d/, function (match, i) {
 *   if (i % 2) this.push(+match[0]);
 * }, []);
 * // -> [2, 4]
 */
    self.forEach = function (str, regex, callback, context) {
        var pos = 0,
            i = -1,
            match;
        while ((match = self.exec(str, regex, pos))) {
            callback.call(context, match, ++i, str, regex);
            pos = match.index + (match[0].length || 1);
        }
        return context;
    };

/**
 * Copies a regex object and adds flag `g`. The copy maintains special properties for named
 * capture, is augmented with `XRegExp.prototype` methods, and has a fresh `lastIndex` property
 * (set to zero). Native regexes are not recompiled using XRegExp syntax.
 * @memberOf XRegExp
 * @param {RegExp} regex Regex to globalize.
 * @returns {RegExp} Copy of the provided regex with flag `g` added.
 * @example
 *
 * var globalCopy = XRegExp.globalize(/regex/);
 * globalCopy.global; // -> true
 */
    self.globalize = function (regex) {
        return copy(regex, "g");
    };

/**
 * Installs optional features according to the specified options.
 * @memberOf XRegExp
 * @param {Object|String} options Options object or string.
 * @example
 *
 * // With an options object
 * XRegExp.install({
 *   // Overrides native regex methods with fixed/extended versions that support named
 *   // backreferences and fix numerous cross-browser bugs
 *   natives: true,
 *
 *   // Enables extensibility of XRegExp syntax and flags
 *   extensibility: true
 * });
 *
 * // With an options string
 * XRegExp.install('natives extensibility');
 *
 * // Using a shortcut to install all optional features
 * XRegExp.install('all');
 */
    self.install = function (options) {
        options = prepareOptions(options);
        if (!features.natives && options.natives) {
            setNatives(true);
        }
        if (!features.extensibility && options.extensibility) {
            setExtensibility(true);
        }
    };

/**
 * Checks whether an individual optional feature is installed.
 * @memberOf XRegExp
 * @param {String} feature Name of the feature to check. One of:
 *   <li>`natives`
 *   <li>`extensibility`
 * @returns {Boolean} Whether the feature is installed.
 * @example
 *
 * XRegExp.isInstalled('natives');
 */
    self.isInstalled = function (feature) {
        return !!(features[feature]);
    };

/**
 * Returns `true` if an object is a regex; `false` if it isn't. This works correctly for regexes
 * created in another frame, when `instanceof` and `constructor` checks would fail.
 * @memberOf XRegExp
 * @param {*} value Object to check.
 * @returns {Boolean} Whether the object is a `RegExp` object.
 * @example
 *
 * XRegExp.isRegExp('string'); // -> false
 * XRegExp.isRegExp(/regex/i); // -> true
 * XRegExp.isRegExp(RegExp('^', 'm')); // -> true
 * XRegExp.isRegExp(XRegExp('(?s).')); // -> true
 */
    self.isRegExp = function (value) {
        return isType(value, "regexp");
    };

/**
 * Retrieves the matches from searching a string using a chain of regexes that successively search
 * within previous matches. The provided `chain` array can contain regexes and objects with `regex`
 * and `backref` properties. When a backreference is specified, the named or numbered backreference
 * is passed forward to the next regex or returned.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {Array} chain Regexes that each search for matches within preceding results.
 * @returns {Array} Matches by the last regex in the chain, or an empty array.
 * @example
 *
 * // Basic usage; matches numbers within <b> tags
 * XRegExp.matchChain('1 <b>2</b> 3 <b>4 a 56</b>', [
 *   XRegExp('(?is)<b>.*?</b>'),
 *   /\d+/
 * ]);
 * // -> ['2', '4', '56']
 *
 * // Passing forward and returning specific backreferences
 * html = '<a href="http://xregexp.com/api/">XRegExp</a>\
 *         <a href="http://www.google.com/">Google</a>';
 * XRegExp.matchChain(html, [
 *   {regex: /<a href="([^"]+)">/i, backref: 1},
 *   {regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
 * ]);
 * // -> ['xregexp.com', 'www.google.com']
 */
    self.matchChain = function (str, chain) {
        return (function recurseChain(values, level) {
            var item = chain[level].regex ? chain[level] : {regex: chain[level]},
                matches = [],
                addMatch = function (match) {
                    matches.push(item.backref ? (match[item.backref] || "") : match[0]);
                },
                i;
            for (i = 0; i < values.length; ++i) {
                self.forEach(values[i], item.regex, addMatch);
            }
            return ((level === chain.length - 1) || !matches.length) ?
                    matches :
                    recurseChain(matches, level + 1);
        }([str], 0));
    };

/**
 * Returns a new string with one or all matches of a pattern replaced. The pattern can be a string
 * or regex, and the replacement can be a string or a function to be called for each match. To
 * perform a global search and replace, use the optional `scope` argument or include flag `g` if
 * using a regex. Replacement strings can use `${n}` for named and numbered backreferences.
 * Replacement functions can use named backreferences via `arguments[0].name`. Also fixes browser
 * bugs compared to the native `String.prototype.replace` and can be used reliably cross-browser.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {RegExp|String} search Search pattern to be replaced.
 * @param {String|Function} replacement Replacement string or a function invoked to create it.
 *   Replacement strings can include special replacement syntax:
 *     <li>$$ - Inserts a literal '$'.
 *     <li>$&, $0 - Inserts the matched substring.
 *     <li>$` - Inserts the string that precedes the matched substring (left context).
 *     <li>$' - Inserts the string that follows the matched substring (right context).
 *     <li>$n, $nn - Where n/nn are digits referencing an existent capturing group, inserts
 *       backreference n/nn.
 *     <li>${n} - Where n is a name or any number of digits that reference an existent capturing
 *       group, inserts backreference n.
 *   Replacement functions are invoked with three or more arguments:
 *     <li>The matched substring (corresponds to $& above). Named backreferences are accessible as
 *       properties of this first argument.
 *     <li>0..n arguments, one for each backreference (corresponding to $1, $2, etc. above).
 *     <li>The zero-based index of the match within the total search string.
 *     <li>The total string being searched.
 * @param {String} [scope='one'] Use 'one' to replace the first match only, or 'all'. If not
 *   explicitly specified and using a regex with flag `g`, `scope` is 'all'.
 * @returns {String} New string with one or all matches replaced.
 * @example
 *
 * // Regex search, using named backreferences in replacement string
 * var name = XRegExp('(?<first>\\w+) (?<last>\\w+)');
 * XRegExp.replace('John Smith', name, '${last}, ${first}');
 * // -> 'Smith, John'
 *
 * // Regex search, using named backreferences in replacement function
 * XRegExp.replace('John Smith', name, function (match) {
 *   return match.last + ', ' + match.first;
 * });
 * // -> 'Smith, John'
 *
 * // Global string search/replacement
 * XRegExp.replace('RegExp builds RegExps', 'RegExp', 'XRegExp', 'all');
 * // -> 'XRegExp builds XRegExps'
 */
    self.replace = function (str, search, replacement, scope) {
        var isRegex = self.isRegExp(search),
            search2 = search,
            result;
        if (isRegex) {
            if (scope === undef && search.global) {
                scope = "all"; // Follow flag g when `scope` isn't explicit
            }
            // Note that since a copy is used, `search`'s `lastIndex` isn't updated *during* replacement iterations
            search2 = copy(search, scope === "all" ? "g" : "", scope === "all" ? "" : "g");
        } else if (scope === "all") {
            search2 = new RegExp(self.escape(String(search)), "g");
        }
        result = fixed.replace.call(String(str), search2, replacement); // Fixed `replace` required for named backreferences, etc.
        if (isRegex && search.global) {
            search.lastIndex = 0; // Fixes IE, Safari bug (last tested IE 9, Safari 5.1)
        }
        return result;
    };

/**
 * Splits a string into an array of strings using a regex or string separator. Matches of the
 * separator are not included in the result array. However, if `separator` is a regex that contains
 * capturing groups, backreferences are spliced into the result each time `separator` is matched.
 * Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably
 * cross-browser.
 * @memberOf XRegExp
 * @param {String} str String to split.
 * @param {RegExp|String} separator Regex or string to use for separating the string.
 * @param {Number} [limit] Maximum number of items to include in the result array.
 * @returns {Array} Array of substrings.
 * @example
 *
 * // Basic use
 * XRegExp.split('a b c', ' ');
 * // -> ['a', 'b', 'c']
 *
 * // With limit
 * XRegExp.split('a b c', ' ', 2);
 * // -> ['a', 'b']
 *
 * // Backreferences in result array
 * XRegExp.split('..word1..', /([a-z]+)(\d+)/i);
 * // -> ['..', 'word', '1', '..']
 */
    self.split = function (str, separator, limit) {
        return fixed.split.call(str, separator, limit);
    };

/**
 * Executes a regex search in a specified string. Returns `true` or `false`. Optional `pos` and
 * `sticky` arguments specify the search start position, and whether the match must start at the
 * specified position only. The `lastIndex` property of the provided regex is not used, but is
 * updated for compatibility. Also fixes browser bugs compared to the native
 * `RegExp.prototype.test` and can be used reliably cross-browser.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {RegExp} regex Regex to search with.
 * @param {Number} [pos=0] Zero-based index at which to start the search.
 * @param {Boolean|String} [sticky=false] Whether the match must start at the specified position
 *   only. The string `'sticky'` is accepted as an alternative to `true`.
 * @returns {Boolean} Whether the regex matched the provided value.
 * @example
 *
 * // Basic use
 * XRegExp.test('abc', /c/); // -> true
 *
 * // With pos and sticky
 * XRegExp.test('abc', /c/, 0, 'sticky'); // -> false
 */
    self.test = function (str, regex, pos, sticky) {
        // Do this the easy way :-)
        return !!self.exec(str, regex, pos, sticky);
    };

/**
 * Uninstalls optional features according to the specified options.
 * @memberOf XRegExp
 * @param {Object|String} options Options object or string.
 * @example
 *
 * // With an options object
 * XRegExp.uninstall({
 *   // Restores native regex methods
 *   natives: true,
 *
 *   // Disables additional syntax and flag extensions
 *   extensibility: true
 * });
 *
 * // With an options string
 * XRegExp.uninstall('natives extensibility');
 *
 * // Using a shortcut to uninstall all optional features
 * XRegExp.uninstall('all');
 */
    self.uninstall = function (options) {
        options = prepareOptions(options);
        if (features.natives && options.natives) {
            setNatives(false);
        }
        if (features.extensibility && options.extensibility) {
            setExtensibility(false);
        }
    };

/**
 * Returns an XRegExp object that is the union of the given patterns. Patterns can be provided as
 * regex objects or strings. Metacharacters are escaped in patterns provided as strings.
 * Backreferences in provided regex objects are automatically renumbered to work correctly. Native
 * flags used by provided regexes are ignored in favor of the `flags` argument.
 * @memberOf XRegExp
 * @param {Array} patterns Regexes and strings to combine.
 * @param {String} [flags] Any combination of XRegExp flags.
 * @returns {RegExp} Union of the provided regexes and strings.
 * @example
 *
 * XRegExp.union(['a+b*c', /(dogs)\1/, /(cats)\1/], 'i');
 * // -> /a\+b\*c|(dogs)\1|(cats)\2/i
 *
 * XRegExp.union([XRegExp('(?<pet>dogs)\\k<pet>'), XRegExp('(?<pet>cats)\\k<pet>')]);
 * // -> XRegExp('(?<pet>dogs)\\k<pet>|(?<pet>cats)\\k<pet>')
 */
    self.union = function (patterns, flags) {
        var parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g,
            numCaptures = 0,
            numPriorCaptures,
            captureNames,
            rewrite = function (match, paren, backref) {
                var name = captureNames[numCaptures - numPriorCaptures];
                if (paren) { // Capturing group
                    ++numCaptures;
                    if (name) { // If the current capture has a name
                        return "(?<" + name + ">";
                    }
                } else if (backref) { // Backreference
                    return "\\" + (+backref + numPriorCaptures);
                }
                return match;
            },
            output = [],
            pattern,
            i;
        if (!(isType(patterns, "array") && patterns.length)) {
            throw new TypeError("patterns must be a nonempty array");
        }
        for (i = 0; i < patterns.length; ++i) {
            pattern = patterns[i];
            if (self.isRegExp(pattern)) {
                numPriorCaptures = numCaptures;
                captureNames = (pattern.xregexp && pattern.xregexp.captureNames) || [];
                // Rewrite backreferences. Passing to XRegExp dies on octals and ensures patterns
                // are independently valid; helps keep this simple. Named captures are put back
                output.push(self(pattern.source).source.replace(parts, rewrite));
            } else {
                output.push(self.escape(pattern));
            }
        }
        return self(output.join("|"), flags);
    };

/**
 * The XRegExp version number.
 * @static
 * @memberOf XRegExp
 * @type String
 */
    self.version = "2.0.0";

/*--------------------------------------
 *  Fixed/extended native methods
 *------------------------------------*/

/**
 * Adds named capture support (with backreferences returned as `result.name`), and fixes browser
 * bugs in the native `RegExp.prototype.exec`. Calling `XRegExp.install('natives')` uses this to
 * override the native method. Use via `XRegExp.exec` without overriding natives.
 * @private
 * @param {String} str String to search.
 * @returns {Array} Match array with named backreference properties, or null.
 */
    fixed.exec = function (str) {
        var match, name, r2, origLastIndex, i;
        if (!this.global) {
            origLastIndex = this.lastIndex;
        }
        match = nativ.exec.apply(this, arguments);
        if (match) {
            // Fix browsers whose `exec` methods don't consistently return `undefined` for
            // nonparticipating capturing groups
            if (!compliantExecNpcg && match.length > 1 && lastIndexOf(match, "") > -1) {
                r2 = new RegExp(this.source, nativ.replace.call(getNativeFlags(this), "g", ""));
                // Using `str.slice(match.index)` rather than `match[0]` in case lookahead allowed
                // matching due to characters outside the match
                nativ.replace.call(String(str).slice(match.index), r2, function () {
                    var i;
                    for (i = 1; i < arguments.length - 2; ++i) {
                        if (arguments[i] === undef) {
                            match[i] = undef;
                        }
                    }
                });
            }
            // Attach named capture properties
            if (this.xregexp && this.xregexp.captureNames) {
                for (i = 1; i < match.length; ++i) {
                    name = this.xregexp.captureNames[i - 1];
                    if (name) {
                        match[name] = match[i];
                    }
                }
            }
            // Fix browsers that increment `lastIndex` after zero-length matches
            if (this.global && !match[0].length && (this.lastIndex > match.index)) {
                this.lastIndex = match.index;
            }
        }
        if (!this.global) {
            this.lastIndex = origLastIndex; // Fixes IE, Opera bug (last tested IE 9, Opera 11.6)
        }
        return match;
    };

/**
 * Fixes browser bugs in the native `RegExp.prototype.test`. Calling `XRegExp.install('natives')`
 * uses this to override the native method.
 * @private
 * @param {String} str String to search.
 * @returns {Boolean} Whether the regex matched the provided value.
 */
    fixed.test = function (str) {
        // Do this the easy way :-)
        return !!fixed.exec.call(this, str);
    };

/**
 * Adds named capture support (with backreferences returned as `result.name`), and fixes browser
 * bugs in the native `String.prototype.match`. Calling `XRegExp.install('natives')` uses this to
 * override the native method.
 * @private
 * @param {RegExp} regex Regex to search with.
 * @returns {Array} If `regex` uses flag g, an array of match strings or null. Without flag g, the
 *   result of calling `regex.exec(this)`.
 */
    fixed.match = function (regex) {
        if (!self.isRegExp(regex)) {
            regex = new RegExp(regex); // Use native `RegExp`
        } else if (regex.global) {
            var result = nativ.match.apply(this, arguments);
            regex.lastIndex = 0; // Fixes IE bug
            return result;
        }
        return fixed.exec.call(regex, this);
    };

/**
 * Adds support for `${n}` tokens for named and numbered backreferences in replacement text, and
 * provides named backreferences to replacement functions as `arguments[0].name`. Also fixes
 * browser bugs in replacement text syntax when performing a replacement using a nonregex search
 * value, and the value of a replacement regex's `lastIndex` property during replacement iterations
 * and upon completion. Note that this doesn't support SpiderMonkey's proprietary third (`flags`)
 * argument. Calling `XRegExp.install('natives')` uses this to override the native method. Use via
 * `XRegExp.replace` without overriding natives.
 * @private
 * @param {RegExp|String} search Search pattern to be replaced.
 * @param {String|Function} replacement Replacement string or a function invoked to create it.
 * @returns {String} New string with one or all matches replaced.
 */
    fixed.replace = function (search, replacement) {
        var isRegex = self.isRegExp(search), captureNames, result, str, origLastIndex;
        if (isRegex) {
            if (search.xregexp) {
                captureNames = search.xregexp.captureNames;
            }
            if (!search.global) {
                origLastIndex = search.lastIndex;
            }
        } else {
            search += "";
        }
        if (isType(replacement, "function")) {
            result = nativ.replace.call(String(this), search, function () {
                var args = arguments, i;
                if (captureNames) {
                    // Change the `arguments[0]` string primitive to a `String` object that can store properties
                    args[0] = new String(args[0]);
                    // Store named backreferences on the first argument
                    for (i = 0; i < captureNames.length; ++i) {
                        if (captureNames[i]) {
                            args[0][captureNames[i]] = args[i + 1];
                        }
                    }
                }
                // Update `lastIndex` before calling `replacement`.
                // Fixes IE, Chrome, Firefox, Safari bug (last tested IE 9, Chrome 17, Firefox 11, Safari 5.1)
                if (isRegex && search.global) {
                    search.lastIndex = args[args.length - 2] + args[0].length;
                }
                return replacement.apply(null, args);
            });
        } else {
            str = String(this); // Ensure `args[args.length - 1]` will be a string when given nonstring `this`
            result = nativ.replace.call(str, search, function () {
                var args = arguments; // Keep this function's `arguments` available through closure
                return nativ.replace.call(String(replacement), replacementToken, function ($0, $1, $2) {
                    var n;
                    // Named or numbered backreference with curly brackets
                    if ($1) {
                        /* XRegExp behavior for `${n}`:
                         * 1. Backreference to numbered capture, where `n` is 1+ digits. `0`, `00`, etc. is the entire match.
                         * 2. Backreference to named capture `n`, if it exists and is not a number overridden by numbered capture.
                         * 3. Otherwise, it's an error.
                         */
                        n = +$1; // Type-convert; drop leading zeros
                        if (n <= args.length - 3) {
                            return args[n] || "";
                        }
                        n = captureNames ? lastIndexOf(captureNames, $1) : -1;
                        if (n < 0) {
                            throw new SyntaxError("backreference to undefined group " + $0);
                        }
                        return args[n + 1] || "";
                    }
                    // Else, special variable or numbered backreference (without curly brackets)
                    if ($2 === "$") return "$";
                    if ($2 === "&" || +$2 === 0) return args[0]; // $&, $0 (not followed by 1-9), $00
                    if ($2 === "`") return args[args.length - 1].slice(0, args[args.length - 2]);
                    if ($2 === "'") return args[args.length - 1].slice(args[args.length - 2] + args[0].length);
                    // Else, numbered backreference (without curly brackets)
                    $2 = +$2; // Type-convert; drop leading zero
                    /* XRegExp behavior:
                     * - Backreferences without curly brackets end after 1 or 2 digits. Use `${..}` for more digits.
                     * - `$1` is an error if there are no capturing groups.
                     * - `$10` is an error if there are less than 10 capturing groups. Use `${1}0` instead.
                     * - `$01` is equivalent to `$1` if a capturing group exists, otherwise it's an error.
                     * - `$0` (not followed by 1-9), `$00`, and `$&` are the entire match.
                     * Native behavior, for comparison:
                     * - Backreferences end after 1 or 2 digits. Cannot use backreference to capturing group 100+.
                     * - `$1` is a literal `$1` if there are no capturing groups.
                     * - `$10` is `$1` followed by a literal `0` if there are less than 10 capturing groups.
                     * - `$01` is equivalent to `$1` if a capturing group exists, otherwise it's a literal `$01`.
                     * - `$0` is a literal `$0`. `$&` is the entire match.
                     */
                    if (!isNaN($2)) {
                        if ($2 > args.length - 3) {
                            throw new SyntaxError("backreference to undefined group " + $0);
                        }
                        return args[$2] || "";
                    }
                    throw new SyntaxError("invalid token " + $0);
                });
            });
        }
        if (isRegex) {
            if (search.global) {
                search.lastIndex = 0; // Fixes IE, Safari bug (last tested IE 9, Safari 5.1)
            } else {
                search.lastIndex = origLastIndex; // Fixes IE, Opera bug (last tested IE 9, Opera 11.6)
            }
        }
        return result;
    };

/**
 * Fixes browser bugs in the native `String.prototype.split`. Calling `XRegExp.install('natives')`
 * uses this to override the native method. Use via `XRegExp.split` without overriding natives.
 * @private
 * @param {RegExp|String} separator Regex or string to use for separating the string.
 * @param {Number} [limit] Maximum number of items to include in the result array.
 * @returns {Array} Array of substrings.
 */
    fixed.split = function (separator, limit) {
        if (!self.isRegExp(separator)) {
            return nativ.split.apply(this, arguments); // use faster native method
        }
        var str = String(this),
            origLastIndex = separator.lastIndex,
            output = [],
            lastLastIndex = 0,
            lastLength;
        /* Values for `limit`, per the spec:
         * If undefined: pow(2,32) - 1
         * If 0, Infinity, or NaN: 0
         * If positive number: limit = floor(limit); if (limit >= pow(2,32)) limit -= pow(2,32);
         * If negative number: pow(2,32) - floor(abs(limit))
         * If other: Type-convert, then use the above rules
         */
        limit = (limit === undef ? -1 : limit) >>> 0;
        self.forEach(str, separator, function (match) {
            if ((match.index + match[0].length) > lastLastIndex) { // != `if (match[0].length)`
                output.push(str.slice(lastLastIndex, match.index));
                if (match.length > 1 && match.index < str.length) {
                    Array.prototype.push.apply(output, match.slice(1));
                }
                lastLength = match[0].length;
                lastLastIndex = match.index + lastLength;
            }
        });
        if (lastLastIndex === str.length) {
            if (!nativ.test.call(separator, "") || lastLength) {
                output.push("");
            }
        } else {
            output.push(str.slice(lastLastIndex));
        }
        separator.lastIndex = origLastIndex;
        return output.length > limit ? output.slice(0, limit) : output;
    };

/*--------------------------------------
 *  Built-in tokens
 *------------------------------------*/

// Shortcut
    add = addToken.on;

/* Letter identity escapes that natively match literal characters: \p, \P, etc.
 * Should be SyntaxErrors but are allowed in web reality. XRegExp makes them errors for cross-
 * browser consistency and to reserve their syntax, but lets them be superseded by XRegExp addons.
 */
    add(/\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4})|x(?![\dA-Fa-f]{2}))/,
        function (match, scope) {
            // \B is allowed in default scope only
            if (match[1] === "B" && scope === defaultScope) {
                return match[0];
            }
            throw new SyntaxError("invalid escape " + match[0]);
        },
        {scope: "all"});

/* Empty character class: [] or [^]
 * Fixes a critical cross-browser syntax inconsistency. Unless this is standardized (per the spec),
 * regex syntax can't be accurately parsed because character class endings can't be determined.
 */
    add(/\[(\^?)]/,
        function (match) {
            // For cross-browser compatibility with ES3, convert [] to \b\B and [^] to [\s\S].
            // (?!) should work like \b\B, but is unreliable in Firefox
            return match[1] ? "[\\s\\S]" : "\\b\\B";
        });

/* Comment pattern: (?# )
 * Inline comments are an alternative to the line comments allowed in free-spacing mode (flag x).
 */
    add(/(?:\(\?#[^)]*\))+/,
        function (match) {
            // Keep tokens separated unless the following token is a quantifier
            return nativ.test.call(quantifier, match.input.slice(match.index + match[0].length)) ? "" : "(?:)";
        });

/* Named backreference: \k<name>
 * Backreference names can use the characters A-Z, a-z, 0-9, _, and $ only.
 */
    add(/\\k<([\w$]+)>/,
        function (match) {
            var index = isNaN(match[1]) ? (lastIndexOf(this.captureNames, match[1]) + 1) : +match[1],
                endIndex = match.index + match[0].length;
            if (!index || index > this.captureNames.length) {
                throw new SyntaxError("backreference to undefined group " + match[0]);
            }
            // Keep backreferences separate from subsequent literal numbers
            return "\\" + index + (
                endIndex === match.input.length || isNaN(match.input.charAt(endIndex)) ? "" : "(?:)"
            );
        });

/* Whitespace and line comments, in free-spacing mode (aka extended mode, flag x) only.
 */
    add(/(?:\s+|#.*)+/,
        function (match) {
            // Keep tokens separated unless the following token is a quantifier
            return nativ.test.call(quantifier, match.input.slice(match.index + match[0].length)) ? "" : "(?:)";
        },
        {
            trigger: function () {
                return this.hasFlag("x");
            },
            customFlags: "x"
        });

/* Dot, in dotall mode (aka singleline mode, flag s) only.
 */
    add(/\./,
        function () {
            return "[\\s\\S]";
        },
        {
            trigger: function () {
                return this.hasFlag("s");
            },
            customFlags: "s"
        });

/* Named capturing group; match the opening delimiter only: (?<name>
 * Capture names can use the characters A-Z, a-z, 0-9, _, and $ only. Names can't be integers.
 * Supports Python-style (?P<name> as an alternate syntax to avoid issues in recent Opera (which
 * natively supports the Python-style syntax). Otherwise, XRegExp might treat numbered
 * backreferences to Python-style named capture as octals.
 */
    add(/\(\?P?<([\w$]+)>/,
        function (match) {
            if (!isNaN(match[1])) {
                // Avoid incorrect lookups, since named backreferences are added to match arrays
                throw new SyntaxError("can't use integer as capture name " + match[0]);
            }
            this.captureNames.push(match[1]);
            this.hasNamedCapture = true;
            return "(";
        });

/* Numbered backreference or octal, plus any following digits: \0, \11, etc.
 * Octals except \0 not followed by 0-9 and backreferences to unopened capture groups throw an
 * error. Other matches are returned unaltered. IE <= 8 doesn't support backreferences greater than
 * \99 in regex syntax.
 */
    add(/\\(\d+)/,
        function (match, scope) {
            if (!(scope === defaultScope && /^[1-9]/.test(match[1]) && +match[1] <= this.captureNames.length) &&
                    match[1] !== "0") {
                throw new SyntaxError("can't use octal escape or backreference to undefined group " + match[0]);
            }
            return match[0];
        },
        {scope: "all"});

/* Capturing group; match the opening parenthesis only.
 * Required for support of named capturing groups. Also adds explicit capture mode (flag n).
 */
    add(/\((?!\?)/,
        function () {
            if (this.hasFlag("n")) {
                return "(?:";
            }
            this.captureNames.push(null);
            return "(";
        },
        {customFlags: "n"});

/*--------------------------------------
 *  Expose XRegExp
 *------------------------------------*/

// For CommonJS enviroments
    if (typeof exports !== "undefined") {
        exports.XRegExp = self;
    }

    return self;

}());


/***** unicode-base.js *****/

/*!
 * XRegExp Unicode Base v1.0.0
 * (c) 2008-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds support for the `\p{L}` or `\p{Letter}` Unicode category. Addon packages for other Unicode
 * categories, scripts, blocks, and properties are available separately. All Unicode tokens can be
 * inverted using `\P{..}` or `\p{^..}`. Token names are case insensitive, and any spaces, hyphens,
 * and underscores are ignored.
 * @requires XRegExp
 */
(function (XRegExp) {
    "use strict";

    var unicode = {};

/*--------------------------------------
 *  Private helper functions
 *------------------------------------*/

// Generates a standardized token name (lowercase, with hyphens, spaces, and underscores removed)
    function slug(name) {
        return name.replace(/[- _]+/g, "").toLowerCase();
    }

// Expands a list of Unicode code points and ranges to be usable in a regex character class
    function expand(str) {
        return str.replace(/\w{4}/g, "\\u$&");
    }

// Adds leading zeros if shorter than four characters
    function pad4(str) {
        while (str.length < 4) {
            str = "0" + str;
        }
        return str;
    }

// Converts a hexadecimal number to decimal
    function dec(hex) {
        return parseInt(hex, 16);
    }

// Converts a decimal number to hexadecimal
    function hex(dec) {
        return parseInt(dec, 10).toString(16);
    }

// Inverts a list of Unicode code points and ranges
    function invert(range) {
        var output = [],
            lastEnd = -1,
            start;
        XRegExp.forEach(range, /\\u(\w{4})(?:-\\u(\w{4}))?/, function (m) {
            start = dec(m[1]);
            if (start > (lastEnd + 1)) {
                output.push("\\u" + pad4(hex(lastEnd + 1)));
                if (start > (lastEnd + 2)) {
                    output.push("-\\u" + pad4(hex(start - 1)));
                }
            }
            lastEnd = dec(m[2] || m[1]);
        });
        if (lastEnd < 0xFFFF) {
            output.push("\\u" + pad4(hex(lastEnd + 1)));
            if (lastEnd < 0xFFFE) {
                output.push("-\\uFFFF");
            }
        }
        return output.join("");
    }

// Generates an inverted token on first use
    function cacheInversion(item) {
        return unicode["^" + item] || (unicode["^" + item] = invert(unicode[item]));
    }

/*--------------------------------------
 *  Core functionality
 *------------------------------------*/

    XRegExp.install("extensibility");

/**
 * Adds to the list of Unicode properties that XRegExp regexes can match via \p{..} or \P{..}.
 * @memberOf XRegExp
 * @param {Object} pack Named sets of Unicode code points and ranges.
 * @param {Object} [aliases] Aliases for the primary token names.
 * @example
 *
 * XRegExp.addUnicodePackage({
 *   XDigit: '0030-00390041-00460061-0066' // 0-9A-Fa-f
 * }, {
 *   XDigit: 'Hexadecimal'
 * });
 */
    XRegExp.addUnicodePackage = function (pack, aliases) {
        var p;
        if (!XRegExp.isInstalled("extensibility")) {
            throw new Error("extensibility must be installed before adding Unicode packages");
        }
        if (pack) {
            for (p in pack) {
                if (pack.hasOwnProperty(p)) {
                    unicode[slug(p)] = expand(pack[p]);
                }
            }
        }
        if (aliases) {
            for (p in aliases) {
                if (aliases.hasOwnProperty(p)) {
                    unicode[slug(aliases[p])] = unicode[slug(p)];
                }
            }
        }
    };

/* Adds data for the Unicode `Letter` category. Addon packages include other categories, scripts,
 * blocks, and properties.
 */
    XRegExp.addUnicodePackage({
        L: "0041-005A0061-007A00AA00B500BA00C0-00D600D8-00F600F8-02C102C6-02D102E0-02E402EC02EE0370-037403760377037A-037D03860388-038A038C038E-03A103A3-03F503F7-0481048A-05270531-055605590561-058705D0-05EA05F0-05F20620-064A066E066F0671-06D306D506E506E606EE06EF06FA-06FC06FF07100712-072F074D-07A507B107CA-07EA07F407F507FA0800-0815081A082408280840-085808A008A2-08AC0904-0939093D09500958-09610971-09770979-097F0985-098C098F09900993-09A809AA-09B009B209B6-09B909BD09CE09DC09DD09DF-09E109F009F10A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A59-0A5C0A5E0A72-0A740A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABD0AD00AE00AE10B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3D0B5C0B5D0B5F-0B610B710B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BD00C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D0C580C590C600C610C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBD0CDE0CE00CE10CF10CF20D05-0D0C0D0E-0D100D12-0D3A0D3D0D4E0D600D610D7A-0D7F0D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60E01-0E300E320E330E40-0E460E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB00EB20EB30EBD0EC0-0EC40EC60EDC-0EDF0F000F40-0F470F49-0F6C0F88-0F8C1000-102A103F1050-1055105A-105D106110651066106E-10701075-1081108E10A0-10C510C710CD10D0-10FA10FC-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A1380-138F13A0-13F41401-166C166F-167F1681-169A16A0-16EA1700-170C170E-17111720-17311740-17511760-176C176E-17701780-17B317D717DC1820-18771880-18A818AA18B0-18F51900-191C1950-196D1970-19741980-19AB19C1-19C71A00-1A161A20-1A541AA71B05-1B331B45-1B4B1B83-1BA01BAE1BAF1BBA-1BE51C00-1C231C4D-1C4F1C5A-1C7D1CE9-1CEC1CEE-1CF11CF51CF61D00-1DBF1E00-1F151F18-1F1D1F20-1F451F48-1F4D1F50-1F571F591F5B1F5D1F5F-1F7D1F80-1FB41FB6-1FBC1FBE1FC2-1FC41FC6-1FCC1FD0-1FD31FD6-1FDB1FE0-1FEC1FF2-1FF41FF6-1FFC2071207F2090-209C21022107210A-211321152119-211D212421262128212A-212D212F-2139213C-213F2145-2149214E218321842C00-2C2E2C30-2C5E2C60-2CE42CEB-2CEE2CF22CF32D00-2D252D272D2D2D30-2D672D6F2D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE2E2F300530063031-3035303B303C3041-3096309D-309F30A1-30FA30FC-30FF3105-312D3131-318E31A0-31BA31F0-31FF3400-4DB54E00-9FCCA000-A48CA4D0-A4FDA500-A60CA610-A61FA62AA62BA640-A66EA67F-A697A6A0-A6E5A717-A71FA722-A788A78B-A78EA790-A793A7A0-A7AAA7F8-A801A803-A805A807-A80AA80C-A822A840-A873A882-A8B3A8F2-A8F7A8FBA90A-A925A930-A946A960-A97CA984-A9B2A9CFAA00-AA28AA40-AA42AA44-AA4BAA60-AA76AA7AAA80-AAAFAAB1AAB5AAB6AAB9-AABDAAC0AAC2AADB-AADDAAE0-AAEAAAF2-AAF4AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABE2AC00-D7A3D7B0-D7C6D7CB-D7FBF900-FA6DFA70-FAD9FB00-FB06FB13-FB17FB1DFB1F-FB28FB2A-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBB1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFBFE70-FE74FE76-FEFCFF21-FF3AFF41-FF5AFF66-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC"
    }, {
        L: "Letter"
    });

/* Adds Unicode property syntax to XRegExp: \p{..}, \P{..}, \p{^..}
 */
    XRegExp.addToken(
        /\\([pP]){(\^?)([^}]*)}/,
        function (match, scope) {
            var inv = (match[1] === "P" || match[2]) ? "^" : "",
                item = slug(match[3]);
            // The double negative \P{^..} is invalid
            if (match[1] === "P" && match[2]) {
                throw new SyntaxError("invalid double negation \\P{^");
            }
            if (!unicode.hasOwnProperty(item)) {
                throw new SyntaxError("invalid or unknown Unicode property " + match[0]);
            }
            return scope === "class" ?
                    (inv ? cacheInversion(item) : unicode[item]) :
                    "[" + inv + unicode[item] + "]";
        },
        {scope: "all"}
    );

}(XRegExp));


/***** unicode-categories.js *****/

/*!
 * XRegExp Unicode Categories v1.2.0
 * (c) 2010-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds support for all Unicode categories (aka properties) E.g., `\p{Lu}` or
 * `\p{Uppercase Letter}`. Token names are case insensitive, and any spaces, hyphens, and
 * underscores are ignored.
 * @requires XRegExp, XRegExp Unicode Base
 */
(function (XRegExp) {
    "use strict";

    if (!XRegExp.addUnicodePackage) {
        throw new ReferenceError("Unicode Base must be loaded before Unicode Categories");
    }

    XRegExp.install("extensibility");

    XRegExp.addUnicodePackage({
        //L: "", // Included in the Unicode Base addon
        Ll: "0061-007A00B500DF-00F600F8-00FF01010103010501070109010B010D010F01110113011501170119011B011D011F01210123012501270129012B012D012F01310133013501370138013A013C013E014001420144014601480149014B014D014F01510153015501570159015B015D015F01610163016501670169016B016D016F0171017301750177017A017C017E-0180018301850188018C018D019201950199-019B019E01A101A301A501A801AA01AB01AD01B001B401B601B901BA01BD-01BF01C601C901CC01CE01D001D201D401D601D801DA01DC01DD01DF01E101E301E501E701E901EB01ED01EF01F001F301F501F901FB01FD01FF02010203020502070209020B020D020F02110213021502170219021B021D021F02210223022502270229022B022D022F02310233-0239023C023F0240024202470249024B024D024F-02930295-02AF037103730377037B-037D039003AC-03CE03D003D103D5-03D703D903DB03DD03DF03E103E303E503E703E903EB03ED03EF-03F303F503F803FB03FC0430-045F04610463046504670469046B046D046F04710473047504770479047B047D047F0481048B048D048F04910493049504970499049B049D049F04A104A304A504A704A904AB04AD04AF04B104B304B504B704B904BB04BD04BF04C204C404C604C804CA04CC04CE04CF04D104D304D504D704D904DB04DD04DF04E104E304E504E704E904EB04ED04EF04F104F304F504F704F904FB04FD04FF05010503050505070509050B050D050F05110513051505170519051B051D051F05210523052505270561-05871D00-1D2B1D6B-1D771D79-1D9A1E011E031E051E071E091E0B1E0D1E0F1E111E131E151E171E191E1B1E1D1E1F1E211E231E251E271E291E2B1E2D1E2F1E311E331E351E371E391E3B1E3D1E3F1E411E431E451E471E491E4B1E4D1E4F1E511E531E551E571E591E5B1E5D1E5F1E611E631E651E671E691E6B1E6D1E6F1E711E731E751E771E791E7B1E7D1E7F1E811E831E851E871E891E8B1E8D1E8F1E911E931E95-1E9D1E9F1EA11EA31EA51EA71EA91EAB1EAD1EAF1EB11EB31EB51EB71EB91EBB1EBD1EBF1EC11EC31EC51EC71EC91ECB1ECD1ECF1ED11ED31ED51ED71ED91EDB1EDD1EDF1EE11EE31EE51EE71EE91EEB1EED1EEF1EF11EF31EF51EF71EF91EFB1EFD1EFF-1F071F10-1F151F20-1F271F30-1F371F40-1F451F50-1F571F60-1F671F70-1F7D1F80-1F871F90-1F971FA0-1FA71FB0-1FB41FB61FB71FBE1FC2-1FC41FC61FC71FD0-1FD31FD61FD71FE0-1FE71FF2-1FF41FF61FF7210A210E210F2113212F21342139213C213D2146-2149214E21842C30-2C5E2C612C652C662C682C6A2C6C2C712C732C742C76-2C7B2C812C832C852C872C892C8B2C8D2C8F2C912C932C952C972C992C9B2C9D2C9F2CA12CA32CA52CA72CA92CAB2CAD2CAF2CB12CB32CB52CB72CB92CBB2CBD2CBF2CC12CC32CC52CC72CC92CCB2CCD2CCF2CD12CD32CD52CD72CD92CDB2CDD2CDF2CE12CE32CE42CEC2CEE2CF32D00-2D252D272D2DA641A643A645A647A649A64BA64DA64FA651A653A655A657A659A65BA65DA65FA661A663A665A667A669A66BA66DA681A683A685A687A689A68BA68DA68FA691A693A695A697A723A725A727A729A72BA72DA72F-A731A733A735A737A739A73BA73DA73FA741A743A745A747A749A74BA74DA74FA751A753A755A757A759A75BA75DA75FA761A763A765A767A769A76BA76DA76FA771-A778A77AA77CA77FA781A783A785A787A78CA78EA791A793A7A1A7A3A7A5A7A7A7A9A7FAFB00-FB06FB13-FB17FF41-FF5A",
        Lu: "0041-005A00C0-00D600D8-00DE01000102010401060108010A010C010E01100112011401160118011A011C011E01200122012401260128012A012C012E01300132013401360139013B013D013F0141014301450147014A014C014E01500152015401560158015A015C015E01600162016401660168016A016C016E017001720174017601780179017B017D018101820184018601870189-018B018E-0191019301940196-0198019C019D019F01A001A201A401A601A701A901AC01AE01AF01B1-01B301B501B701B801BC01C401C701CA01CD01CF01D101D301D501D701D901DB01DE01E001E201E401E601E801EA01EC01EE01F101F401F6-01F801FA01FC01FE02000202020402060208020A020C020E02100212021402160218021A021C021E02200222022402260228022A022C022E02300232023A023B023D023E02410243-02460248024A024C024E03700372037603860388-038A038C038E038F0391-03A103A3-03AB03CF03D2-03D403D803DA03DC03DE03E003E203E403E603E803EA03EC03EE03F403F703F903FA03FD-042F04600462046404660468046A046C046E04700472047404760478047A047C047E0480048A048C048E04900492049404960498049A049C049E04A004A204A404A604A804AA04AC04AE04B004B204B404B604B804BA04BC04BE04C004C104C304C504C704C904CB04CD04D004D204D404D604D804DA04DC04DE04E004E204E404E604E804EA04EC04EE04F004F204F404F604F804FA04FC04FE05000502050405060508050A050C050E05100512051405160518051A051C051E05200522052405260531-055610A0-10C510C710CD1E001E021E041E061E081E0A1E0C1E0E1E101E121E141E161E181E1A1E1C1E1E1E201E221E241E261E281E2A1E2C1E2E1E301E321E341E361E381E3A1E3C1E3E1E401E421E441E461E481E4A1E4C1E4E1E501E521E541E561E581E5A1E5C1E5E1E601E621E641E661E681E6A1E6C1E6E1E701E721E741E761E781E7A1E7C1E7E1E801E821E841E861E881E8A1E8C1E8E1E901E921E941E9E1EA01EA21EA41EA61EA81EAA1EAC1EAE1EB01EB21EB41EB61EB81EBA1EBC1EBE1EC01EC21EC41EC61EC81ECA1ECC1ECE1ED01ED21ED41ED61ED81EDA1EDC1EDE1EE01EE21EE41EE61EE81EEA1EEC1EEE1EF01EF21EF41EF61EF81EFA1EFC1EFE1F08-1F0F1F18-1F1D1F28-1F2F1F38-1F3F1F48-1F4D1F591F5B1F5D1F5F1F68-1F6F1FB8-1FBB1FC8-1FCB1FD8-1FDB1FE8-1FEC1FF8-1FFB21022107210B-210D2110-211221152119-211D212421262128212A-212D2130-2133213E213F214521832C00-2C2E2C602C62-2C642C672C692C6B2C6D-2C702C722C752C7E-2C802C822C842C862C882C8A2C8C2C8E2C902C922C942C962C982C9A2C9C2C9E2CA02CA22CA42CA62CA82CAA2CAC2CAE2CB02CB22CB42CB62CB82CBA2CBC2CBE2CC02CC22CC42CC62CC82CCA2CCC2CCE2CD02CD22CD42CD62CD82CDA2CDC2CDE2CE02CE22CEB2CED2CF2A640A642A644A646A648A64AA64CA64EA650A652A654A656A658A65AA65CA65EA660A662A664A666A668A66AA66CA680A682A684A686A688A68AA68CA68EA690A692A694A696A722A724A726A728A72AA72CA72EA732A734A736A738A73AA73CA73EA740A742A744A746A748A74AA74CA74EA750A752A754A756A758A75AA75CA75EA760A762A764A766A768A76AA76CA76EA779A77BA77DA77EA780A782A784A786A78BA78DA790A792A7A0A7A2A7A4A7A6A7A8A7AAFF21-FF3A",
        Lt: "01C501C801CB01F21F88-1F8F1F98-1F9F1FA8-1FAF1FBC1FCC1FFC",
        Lm: "02B0-02C102C6-02D102E0-02E402EC02EE0374037A0559064006E506E607F407F507FA081A0824082809710E460EC610FC17D718431AA71C78-1C7D1D2C-1D6A1D781D9B-1DBF2071207F2090-209C2C7C2C7D2D6F2E2F30053031-3035303B309D309E30FC-30FEA015A4F8-A4FDA60CA67FA717-A71FA770A788A7F8A7F9A9CFAA70AADDAAF3AAF4FF70FF9EFF9F",
        Lo: "00AA00BA01BB01C0-01C3029405D0-05EA05F0-05F20620-063F0641-064A066E066F0671-06D306D506EE06EF06FA-06FC06FF07100712-072F074D-07A507B107CA-07EA0800-08150840-085808A008A2-08AC0904-0939093D09500958-09610972-09770979-097F0985-098C098F09900993-09A809AA-09B009B209B6-09B909BD09CE09DC09DD09DF-09E109F009F10A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A59-0A5C0A5E0A72-0A740A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABD0AD00AE00AE10B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3D0B5C0B5D0B5F-0B610B710B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BD00C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D0C580C590C600C610C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBD0CDE0CE00CE10CF10CF20D05-0D0C0D0E-0D100D12-0D3A0D3D0D4E0D600D610D7A-0D7F0D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60E01-0E300E320E330E40-0E450E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB00EB20EB30EBD0EC0-0EC40EDC-0EDF0F000F40-0F470F49-0F6C0F88-0F8C1000-102A103F1050-1055105A-105D106110651066106E-10701075-1081108E10D0-10FA10FD-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A1380-138F13A0-13F41401-166C166F-167F1681-169A16A0-16EA1700-170C170E-17111720-17311740-17511760-176C176E-17701780-17B317DC1820-18421844-18771880-18A818AA18B0-18F51900-191C1950-196D1970-19741980-19AB19C1-19C71A00-1A161A20-1A541B05-1B331B45-1B4B1B83-1BA01BAE1BAF1BBA-1BE51C00-1C231C4D-1C4F1C5A-1C771CE9-1CEC1CEE-1CF11CF51CF62135-21382D30-2D672D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE3006303C3041-3096309F30A1-30FA30FF3105-312D3131-318E31A0-31BA31F0-31FF3400-4DB54E00-9FCCA000-A014A016-A48CA4D0-A4F7A500-A60BA610-A61FA62AA62BA66EA6A0-A6E5A7FB-A801A803-A805A807-A80AA80C-A822A840-A873A882-A8B3A8F2-A8F7A8FBA90A-A925A930-A946A960-A97CA984-A9B2AA00-AA28AA40-AA42AA44-AA4BAA60-AA6FAA71-AA76AA7AAA80-AAAFAAB1AAB5AAB6AAB9-AABDAAC0AAC2AADBAADCAAE0-AAEAAAF2AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABE2AC00-D7A3D7B0-D7C6D7CB-D7FBF900-FA6DFA70-FAD9FB1DFB1F-FB28FB2A-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBB1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFBFE70-FE74FE76-FEFCFF66-FF6FFF71-FF9DFFA0-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC",
        M: "0300-036F0483-04890591-05BD05BF05C105C205C405C505C70610-061A064B-065F067006D6-06DC06DF-06E406E706E806EA-06ED07110730-074A07A6-07B007EB-07F30816-0819081B-08230825-08270829-082D0859-085B08E4-08FE0900-0903093A-093C093E-094F0951-0957096209630981-098309BC09BE-09C409C709C809CB-09CD09D709E209E30A01-0A030A3C0A3E-0A420A470A480A4B-0A4D0A510A700A710A750A81-0A830ABC0ABE-0AC50AC7-0AC90ACB-0ACD0AE20AE30B01-0B030B3C0B3E-0B440B470B480B4B-0B4D0B560B570B620B630B820BBE-0BC20BC6-0BC80BCA-0BCD0BD70C01-0C030C3E-0C440C46-0C480C4A-0C4D0C550C560C620C630C820C830CBC0CBE-0CC40CC6-0CC80CCA-0CCD0CD50CD60CE20CE30D020D030D3E-0D440D46-0D480D4A-0D4D0D570D620D630D820D830DCA0DCF-0DD40DD60DD8-0DDF0DF20DF30E310E34-0E3A0E47-0E4E0EB10EB4-0EB90EBB0EBC0EC8-0ECD0F180F190F350F370F390F3E0F3F0F71-0F840F860F870F8D-0F970F99-0FBC0FC6102B-103E1056-1059105E-10601062-10641067-106D1071-10741082-108D108F109A-109D135D-135F1712-17141732-1734175217531772177317B4-17D317DD180B-180D18A91920-192B1930-193B19B0-19C019C819C91A17-1A1B1A55-1A5E1A60-1A7C1A7F1B00-1B041B34-1B441B6B-1B731B80-1B821BA1-1BAD1BE6-1BF31C24-1C371CD0-1CD21CD4-1CE81CED1CF2-1CF41DC0-1DE61DFC-1DFF20D0-20F02CEF-2CF12D7F2DE0-2DFF302A-302F3099309AA66F-A672A674-A67DA69FA6F0A6F1A802A806A80BA823-A827A880A881A8B4-A8C4A8E0-A8F1A926-A92DA947-A953A980-A983A9B3-A9C0AA29-AA36AA43AA4CAA4DAA7BAAB0AAB2-AAB4AAB7AAB8AABEAABFAAC1AAEB-AAEFAAF5AAF6ABE3-ABEAABECABEDFB1EFE00-FE0FFE20-FE26",
        Mn: "0300-036F0483-04870591-05BD05BF05C105C205C405C505C70610-061A064B-065F067006D6-06DC06DF-06E406E706E806EA-06ED07110730-074A07A6-07B007EB-07F30816-0819081B-08230825-08270829-082D0859-085B08E4-08FE0900-0902093A093C0941-0948094D0951-095709620963098109BC09C1-09C409CD09E209E30A010A020A3C0A410A420A470A480A4B-0A4D0A510A700A710A750A810A820ABC0AC1-0AC50AC70AC80ACD0AE20AE30B010B3C0B3F0B41-0B440B4D0B560B620B630B820BC00BCD0C3E-0C400C46-0C480C4A-0C4D0C550C560C620C630CBC0CBF0CC60CCC0CCD0CE20CE30D41-0D440D4D0D620D630DCA0DD2-0DD40DD60E310E34-0E3A0E47-0E4E0EB10EB4-0EB90EBB0EBC0EC8-0ECD0F180F190F350F370F390F71-0F7E0F80-0F840F860F870F8D-0F970F99-0FBC0FC6102D-10301032-10371039103A103D103E10581059105E-10601071-1074108210851086108D109D135D-135F1712-17141732-1734175217531772177317B417B517B7-17BD17C617C9-17D317DD180B-180D18A91920-19221927192819321939-193B1A171A181A561A58-1A5E1A601A621A65-1A6C1A73-1A7C1A7F1B00-1B031B341B36-1B3A1B3C1B421B6B-1B731B801B811BA2-1BA51BA81BA91BAB1BE61BE81BE91BED1BEF-1BF11C2C-1C331C361C371CD0-1CD21CD4-1CE01CE2-1CE81CED1CF41DC0-1DE61DFC-1DFF20D0-20DC20E120E5-20F02CEF-2CF12D7F2DE0-2DFF302A-302D3099309AA66FA674-A67DA69FA6F0A6F1A802A806A80BA825A826A8C4A8E0-A8F1A926-A92DA947-A951A980-A982A9B3A9B6-A9B9A9BCAA29-AA2EAA31AA32AA35AA36AA43AA4CAAB0AAB2-AAB4AAB7AAB8AABEAABFAAC1AAECAAEDAAF6ABE5ABE8ABEDFB1EFE00-FE0FFE20-FE26",
        Mc: "0903093B093E-09400949-094C094E094F0982098309BE-09C009C709C809CB09CC09D70A030A3E-0A400A830ABE-0AC00AC90ACB0ACC0B020B030B3E0B400B470B480B4B0B4C0B570BBE0BBF0BC10BC20BC6-0BC80BCA-0BCC0BD70C01-0C030C41-0C440C820C830CBE0CC0-0CC40CC70CC80CCA0CCB0CD50CD60D020D030D3E-0D400D46-0D480D4A-0D4C0D570D820D830DCF-0DD10DD8-0DDF0DF20DF30F3E0F3F0F7F102B102C10311038103B103C105610571062-10641067-106D108310841087-108C108F109A-109C17B617BE-17C517C717C81923-19261929-192B193019311933-193819B0-19C019C819C91A19-1A1B1A551A571A611A631A641A6D-1A721B041B351B3B1B3D-1B411B431B441B821BA11BA61BA71BAA1BAC1BAD1BE71BEA-1BEC1BEE1BF21BF31C24-1C2B1C341C351CE11CF21CF3302E302FA823A824A827A880A881A8B4-A8C3A952A953A983A9B4A9B5A9BAA9BBA9BD-A9C0AA2FAA30AA33AA34AA4DAA7BAAEBAAEEAAEFAAF5ABE3ABE4ABE6ABE7ABE9ABEAABEC",
        Me: "0488048920DD-20E020E2-20E4A670-A672",
        N: "0030-003900B200B300B900BC-00BE0660-066906F0-06F907C0-07C90966-096F09E6-09EF09F4-09F90A66-0A6F0AE6-0AEF0B66-0B6F0B72-0B770BE6-0BF20C66-0C6F0C78-0C7E0CE6-0CEF0D66-0D750E50-0E590ED0-0ED90F20-0F331040-10491090-10991369-137C16EE-16F017E0-17E917F0-17F91810-18191946-194F19D0-19DA1A80-1A891A90-1A991B50-1B591BB0-1BB91C40-1C491C50-1C5920702074-20792080-20892150-21822185-21892460-249B24EA-24FF2776-27932CFD30073021-30293038-303A3192-31953220-32293248-324F3251-325F3280-328932B1-32BFA620-A629A6E6-A6EFA830-A835A8D0-A8D9A900-A909A9D0-A9D9AA50-AA59ABF0-ABF9FF10-FF19",
        Nd: "0030-00390660-066906F0-06F907C0-07C90966-096F09E6-09EF0A66-0A6F0AE6-0AEF0B66-0B6F0BE6-0BEF0C66-0C6F0CE6-0CEF0D66-0D6F0E50-0E590ED0-0ED90F20-0F291040-10491090-109917E0-17E91810-18191946-194F19D0-19D91A80-1A891A90-1A991B50-1B591BB0-1BB91C40-1C491C50-1C59A620-A629A8D0-A8D9A900-A909A9D0-A9D9AA50-AA59ABF0-ABF9FF10-FF19",
        Nl: "16EE-16F02160-21822185-218830073021-30293038-303AA6E6-A6EF",
        No: "00B200B300B900BC-00BE09F4-09F90B72-0B770BF0-0BF20C78-0C7E0D70-0D750F2A-0F331369-137C17F0-17F919DA20702074-20792080-20892150-215F21892460-249B24EA-24FF2776-27932CFD3192-31953220-32293248-324F3251-325F3280-328932B1-32BFA830-A835",
        P: "0021-00230025-002A002C-002F003A003B003F0040005B-005D005F007B007D00A100A700AB00B600B700BB00BF037E0387055A-055F0589058A05BE05C005C305C605F305F40609060A060C060D061B061E061F066A-066D06D40700-070D07F7-07F90830-083E085E0964096509700AF00DF40E4F0E5A0E5B0F04-0F120F140F3A-0F3D0F850FD0-0FD40FD90FDA104A-104F10FB1360-13681400166D166E169B169C16EB-16ED1735173617D4-17D617D8-17DA1800-180A194419451A1E1A1F1AA0-1AA61AA8-1AAD1B5A-1B601BFC-1BFF1C3B-1C3F1C7E1C7F1CC0-1CC71CD32010-20272030-20432045-20512053-205E207D207E208D208E2329232A2768-277527C527C627E6-27EF2983-299829D8-29DB29FC29FD2CF9-2CFC2CFE2CFF2D702E00-2E2E2E30-2E3B3001-30033008-30113014-301F3030303D30A030FBA4FEA4FFA60D-A60FA673A67EA6F2-A6F7A874-A877A8CEA8CFA8F8-A8FAA92EA92FA95FA9C1-A9CDA9DEA9DFAA5C-AA5FAADEAADFAAF0AAF1ABEBFD3EFD3FFE10-FE19FE30-FE52FE54-FE61FE63FE68FE6AFE6BFF01-FF03FF05-FF0AFF0C-FF0FFF1AFF1BFF1FFF20FF3B-FF3DFF3FFF5BFF5DFF5F-FF65",
        Pd: "002D058A05BE140018062010-20152E172E1A2E3A2E3B301C303030A0FE31FE32FE58FE63FF0D",
        Ps: "0028005B007B0F3A0F3C169B201A201E2045207D208D23292768276A276C276E27702772277427C527E627E827EA27EC27EE2983298529872989298B298D298F299129932995299729D829DA29FC2E222E242E262E283008300A300C300E3010301430163018301A301DFD3EFE17FE35FE37FE39FE3BFE3DFE3FFE41FE43FE47FE59FE5BFE5DFF08FF3BFF5BFF5FFF62",
        Pe: "0029005D007D0F3B0F3D169C2046207E208E232A2769276B276D276F27712773277527C627E727E927EB27ED27EF298429862988298A298C298E2990299229942996299829D929DB29FD2E232E252E272E293009300B300D300F3011301530173019301B301E301FFD3FFE18FE36FE38FE3AFE3CFE3EFE40FE42FE44FE48FE5AFE5CFE5EFF09FF3DFF5DFF60FF63",
        Pi: "00AB2018201B201C201F20392E022E042E092E0C2E1C2E20",
        Pf: "00BB2019201D203A2E032E052E0A2E0D2E1D2E21",
        Pc: "005F203F20402054FE33FE34FE4D-FE4FFF3F",
        Po: "0021-00230025-0027002A002C002E002F003A003B003F0040005C00A100A700B600B700BF037E0387055A-055F058905C005C305C605F305F40609060A060C060D061B061E061F066A-066D06D40700-070D07F7-07F90830-083E085E0964096509700AF00DF40E4F0E5A0E5B0F04-0F120F140F850FD0-0FD40FD90FDA104A-104F10FB1360-1368166D166E16EB-16ED1735173617D4-17D617D8-17DA1800-18051807-180A194419451A1E1A1F1AA0-1AA61AA8-1AAD1B5A-1B601BFC-1BFF1C3B-1C3F1C7E1C7F1CC0-1CC71CD3201620172020-20272030-2038203B-203E2041-20432047-205120532055-205E2CF9-2CFC2CFE2CFF2D702E002E012E06-2E082E0B2E0E-2E162E182E192E1B2E1E2E1F2E2A-2E2E2E30-2E393001-3003303D30FBA4FEA4FFA60D-A60FA673A67EA6F2-A6F7A874-A877A8CEA8CFA8F8-A8FAA92EA92FA95FA9C1-A9CDA9DEA9DFAA5C-AA5FAADEAADFAAF0AAF1ABEBFE10-FE16FE19FE30FE45FE46FE49-FE4CFE50-FE52FE54-FE57FE5F-FE61FE68FE6AFE6BFF01-FF03FF05-FF07FF0AFF0CFF0EFF0FFF1AFF1BFF1FFF20FF3CFF61FF64FF65",
        S: "0024002B003C-003E005E0060007C007E00A2-00A600A800A900AC00AE-00B100B400B800D700F702C2-02C502D2-02DF02E5-02EB02ED02EF-02FF03750384038503F60482058F0606-0608060B060E060F06DE06E906FD06FE07F609F209F309FA09FB0AF10B700BF3-0BFA0C7F0D790E3F0F01-0F030F130F15-0F170F1A-0F1F0F340F360F380FBE-0FC50FC7-0FCC0FCE0FCF0FD5-0FD8109E109F1390-139917DB194019DE-19FF1B61-1B6A1B74-1B7C1FBD1FBF-1FC11FCD-1FCF1FDD-1FDF1FED-1FEF1FFD1FFE20442052207A-207C208A-208C20A0-20B9210021012103-21062108210921142116-2118211E-2123212521272129212E213A213B2140-2144214A-214D214F2190-2328232B-23F32400-24262440-244A249C-24E92500-26FF2701-27672794-27C427C7-27E527F0-29822999-29D729DC-29FB29FE-2B4C2B50-2B592CE5-2CEA2E80-2E992E9B-2EF32F00-2FD52FF0-2FFB300430123013302030363037303E303F309B309C319031913196-319F31C0-31E33200-321E322A-324732503260-327F328A-32B032C0-32FE3300-33FF4DC0-4DFFA490-A4C6A700-A716A720A721A789A78AA828-A82BA836-A839AA77-AA79FB29FBB2-FBC1FDFCFDFDFE62FE64-FE66FE69FF04FF0BFF1C-FF1EFF3EFF40FF5CFF5EFFE0-FFE6FFE8-FFEEFFFCFFFD",
        Sm: "002B003C-003E007C007E00AC00B100D700F703F60606-060820442052207A-207C208A-208C21182140-2144214B2190-2194219A219B21A021A321A621AE21CE21CF21D221D421F4-22FF2308-230B23202321237C239B-23B323DC-23E125B725C125F8-25FF266F27C0-27C427C7-27E527F0-27FF2900-29822999-29D729DC-29FB29FE-2AFF2B30-2B442B47-2B4CFB29FE62FE64-FE66FF0BFF1C-FF1EFF5CFF5EFFE2FFE9-FFEC",
        Sc: "002400A2-00A5058F060B09F209F309FB0AF10BF90E3F17DB20A0-20B9A838FDFCFE69FF04FFE0FFE1FFE5FFE6",
        Sk: "005E006000A800AF00B400B802C2-02C502D2-02DF02E5-02EB02ED02EF-02FF0375038403851FBD1FBF-1FC11FCD-1FCF1FDD-1FDF1FED-1FEF1FFD1FFE309B309CA700-A716A720A721A789A78AFBB2-FBC1FF3EFF40FFE3",
        So: "00A600A900AE00B00482060E060F06DE06E906FD06FE07F609FA0B700BF3-0BF80BFA0C7F0D790F01-0F030F130F15-0F170F1A-0F1F0F340F360F380FBE-0FC50FC7-0FCC0FCE0FCF0FD5-0FD8109E109F1390-1399194019DE-19FF1B61-1B6A1B74-1B7C210021012103-210621082109211421162117211E-2123212521272129212E213A213B214A214C214D214F2195-2199219C-219F21A121A221A421A521A7-21AD21AF-21CD21D021D121D321D5-21F32300-2307230C-231F2322-2328232B-237B237D-239A23B4-23DB23E2-23F32400-24262440-244A249C-24E92500-25B625B8-25C025C2-25F72600-266E2670-26FF2701-27672794-27BF2800-28FF2B00-2B2F2B452B462B50-2B592CE5-2CEA2E80-2E992E9B-2EF32F00-2FD52FF0-2FFB300430123013302030363037303E303F319031913196-319F31C0-31E33200-321E322A-324732503260-327F328A-32B032C0-32FE3300-33FF4DC0-4DFFA490-A4C6A828-A82BA836A837A839AA77-AA79FDFDFFE4FFE8FFEDFFEEFFFCFFFD",
        Z: "002000A01680180E2000-200A20282029202F205F3000",
        Zs: "002000A01680180E2000-200A202F205F3000",
        Zl: "2028",
        Zp: "2029",
        C: "0000-001F007F-009F00AD03780379037F-0383038B038D03A20528-05300557055805600588058B-058E059005C8-05CF05EB-05EF05F5-0605061C061D06DD070E070F074B074C07B2-07BF07FB-07FF082E082F083F085C085D085F-089F08A108AD-08E308FF097809800984098D098E0991099209A909B109B3-09B509BA09BB09C509C609C909CA09CF-09D609D8-09DB09DE09E409E509FC-0A000A040A0B-0A0E0A110A120A290A310A340A370A3A0A3B0A3D0A43-0A460A490A4A0A4E-0A500A52-0A580A5D0A5F-0A650A76-0A800A840A8E0A920AA90AB10AB40ABA0ABB0AC60ACA0ACE0ACF0AD1-0ADF0AE40AE50AF2-0B000B040B0D0B0E0B110B120B290B310B340B3A0B3B0B450B460B490B4A0B4E-0B550B58-0B5B0B5E0B640B650B78-0B810B840B8B-0B8D0B910B96-0B980B9B0B9D0BA0-0BA20BA5-0BA70BAB-0BAD0BBA-0BBD0BC3-0BC50BC90BCE0BCF0BD1-0BD60BD8-0BE50BFB-0C000C040C0D0C110C290C340C3A-0C3C0C450C490C4E-0C540C570C5A-0C5F0C640C650C70-0C770C800C810C840C8D0C910CA90CB40CBA0CBB0CC50CC90CCE-0CD40CD7-0CDD0CDF0CE40CE50CF00CF3-0D010D040D0D0D110D3B0D3C0D450D490D4F-0D560D58-0D5F0D640D650D76-0D780D800D810D840D97-0D990DB20DBC0DBE0DBF0DC7-0DC90DCB-0DCE0DD50DD70DE0-0DF10DF5-0E000E3B-0E3E0E5C-0E800E830E850E860E890E8B0E8C0E8E-0E930E980EA00EA40EA60EA80EA90EAC0EBA0EBE0EBF0EC50EC70ECE0ECF0EDA0EDB0EE0-0EFF0F480F6D-0F700F980FBD0FCD0FDB-0FFF10C610C8-10CC10CE10CF1249124E124F12571259125E125F1289128E128F12B112B612B712BF12C112C612C712D7131113161317135B135C137D-137F139A-139F13F5-13FF169D-169F16F1-16FF170D1715-171F1737-173F1754-175F176D17711774-177F17DE17DF17EA-17EF17FA-17FF180F181A-181F1878-187F18AB-18AF18F6-18FF191D-191F192C-192F193C-193F1941-1943196E196F1975-197F19AC-19AF19CA-19CF19DB-19DD1A1C1A1D1A5F1A7D1A7E1A8A-1A8F1A9A-1A9F1AAE-1AFF1B4C-1B4F1B7D-1B7F1BF4-1BFB1C38-1C3A1C4A-1C4C1C80-1CBF1CC8-1CCF1CF7-1CFF1DE7-1DFB1F161F171F1E1F1F1F461F471F4E1F4F1F581F5A1F5C1F5E1F7E1F7F1FB51FC51FD41FD51FDC1FF01FF11FF51FFF200B-200F202A-202E2060-206F20722073208F209D-209F20BA-20CF20F1-20FF218A-218F23F4-23FF2427-243F244B-245F27002B4D-2B4F2B5A-2BFF2C2F2C5F2CF4-2CF82D262D28-2D2C2D2E2D2F2D68-2D6E2D71-2D7E2D97-2D9F2DA72DAF2DB72DBF2DC72DCF2DD72DDF2E3C-2E7F2E9A2EF4-2EFF2FD6-2FEF2FFC-2FFF3040309730983100-3104312E-3130318F31BB-31BF31E4-31EF321F32FF4DB6-4DBF9FCD-9FFFA48D-A48FA4C7-A4CFA62C-A63FA698-A69EA6F8-A6FFA78FA794-A79FA7AB-A7F7A82C-A82FA83A-A83FA878-A87FA8C5-A8CDA8DA-A8DFA8FC-A8FFA954-A95EA97D-A97FA9CEA9DA-A9DDA9E0-A9FFAA37-AA3FAA4EAA4FAA5AAA5BAA7C-AA7FAAC3-AADAAAF7-AB00AB07AB08AB0FAB10AB17-AB1FAB27AB2F-ABBFABEEABEFABFA-ABFFD7A4-D7AFD7C7-D7CAD7FC-F8FFFA6EFA6FFADA-FAFFFB07-FB12FB18-FB1CFB37FB3DFB3FFB42FB45FBC2-FBD2FD40-FD4FFD90FD91FDC8-FDEFFDFEFDFFFE1A-FE1FFE27-FE2FFE53FE67FE6C-FE6FFE75FEFD-FF00FFBF-FFC1FFC8FFC9FFD0FFD1FFD8FFD9FFDD-FFDFFFE7FFEF-FFFBFFFEFFFF",
        Cc: "0000-001F007F-009F",
        Cf: "00AD0600-060406DD070F200B-200F202A-202E2060-2064206A-206FFEFFFFF9-FFFB",
        Co: "E000-F8FF",
        Cs: "D800-DFFF",
        Cn: "03780379037F-0383038B038D03A20528-05300557055805600588058B-058E059005C8-05CF05EB-05EF05F5-05FF0605061C061D070E074B074C07B2-07BF07FB-07FF082E082F083F085C085D085F-089F08A108AD-08E308FF097809800984098D098E0991099209A909B109B3-09B509BA09BB09C509C609C909CA09CF-09D609D8-09DB09DE09E409E509FC-0A000A040A0B-0A0E0A110A120A290A310A340A370A3A0A3B0A3D0A43-0A460A490A4A0A4E-0A500A52-0A580A5D0A5F-0A650A76-0A800A840A8E0A920AA90AB10AB40ABA0ABB0AC60ACA0ACE0ACF0AD1-0ADF0AE40AE50AF2-0B000B040B0D0B0E0B110B120B290B310B340B3A0B3B0B450B460B490B4A0B4E-0B550B58-0B5B0B5E0B640B650B78-0B810B840B8B-0B8D0B910B96-0B980B9B0B9D0BA0-0BA20BA5-0BA70BAB-0BAD0BBA-0BBD0BC3-0BC50BC90BCE0BCF0BD1-0BD60BD8-0BE50BFB-0C000C040C0D0C110C290C340C3A-0C3C0C450C490C4E-0C540C570C5A-0C5F0C640C650C70-0C770C800C810C840C8D0C910CA90CB40CBA0CBB0CC50CC90CCE-0CD40CD7-0CDD0CDF0CE40CE50CF00CF3-0D010D040D0D0D110D3B0D3C0D450D490D4F-0D560D58-0D5F0D640D650D76-0D780D800D810D840D97-0D990DB20DBC0DBE0DBF0DC7-0DC90DCB-0DCE0DD50DD70DE0-0DF10DF5-0E000E3B-0E3E0E5C-0E800E830E850E860E890E8B0E8C0E8E-0E930E980EA00EA40EA60EA80EA90EAC0EBA0EBE0EBF0EC50EC70ECE0ECF0EDA0EDB0EE0-0EFF0F480F6D-0F700F980FBD0FCD0FDB-0FFF10C610C8-10CC10CE10CF1249124E124F12571259125E125F1289128E128F12B112B612B712BF12C112C612C712D7131113161317135B135C137D-137F139A-139F13F5-13FF169D-169F16F1-16FF170D1715-171F1737-173F1754-175F176D17711774-177F17DE17DF17EA-17EF17FA-17FF180F181A-181F1878-187F18AB-18AF18F6-18FF191D-191F192C-192F193C-193F1941-1943196E196F1975-197F19AC-19AF19CA-19CF19DB-19DD1A1C1A1D1A5F1A7D1A7E1A8A-1A8F1A9A-1A9F1AAE-1AFF1B4C-1B4F1B7D-1B7F1BF4-1BFB1C38-1C3A1C4A-1C4C1C80-1CBF1CC8-1CCF1CF7-1CFF1DE7-1DFB1F161F171F1E1F1F1F461F471F4E1F4F1F581F5A1F5C1F5E1F7E1F7F1FB51FC51FD41FD51FDC1FF01FF11FF51FFF2065-206920722073208F209D-209F20BA-20CF20F1-20FF218A-218F23F4-23FF2427-243F244B-245F27002B4D-2B4F2B5A-2BFF2C2F2C5F2CF4-2CF82D262D28-2D2C2D2E2D2F2D68-2D6E2D71-2D7E2D97-2D9F2DA72DAF2DB72DBF2DC72DCF2DD72DDF2E3C-2E7F2E9A2EF4-2EFF2FD6-2FEF2FFC-2FFF3040309730983100-3104312E-3130318F31BB-31BF31E4-31EF321F32FF4DB6-4DBF9FCD-9FFFA48D-A48FA4C7-A4CFA62C-A63FA698-A69EA6F8-A6FFA78FA794-A79FA7AB-A7F7A82C-A82FA83A-A83FA878-A87FA8C5-A8CDA8DA-A8DFA8FC-A8FFA954-A95EA97D-A97FA9CEA9DA-A9DDA9E0-A9FFAA37-AA3FAA4EAA4FAA5AAA5BAA7C-AA7FAAC3-AADAAAF7-AB00AB07AB08AB0FAB10AB17-AB1FAB27AB2F-ABBFABEEABEFABFA-ABFFD7A4-D7AFD7C7-D7CAD7FC-D7FFFA6EFA6FFADA-FAFFFB07-FB12FB18-FB1CFB37FB3DFB3FFB42FB45FBC2-FBD2FD40-FD4FFD90FD91FDC8-FDEFFDFEFDFFFE1A-FE1FFE27-FE2FFE53FE67FE6C-FE6FFE75FEFDFEFEFF00FFBF-FFC1FFC8FFC9FFD0FFD1FFD8FFD9FFDD-FFDFFFE7FFEF-FFF8FFFEFFFF"
    }, {
        //L: "Letter", // Included in the Unicode Base addon
        Ll: "Lowercase_Letter",
        Lu: "Uppercase_Letter",
        Lt: "Titlecase_Letter",
        Lm: "Modifier_Letter",
        Lo: "Other_Letter",
        M: "Mark",
        Mn: "Nonspacing_Mark",
        Mc: "Spacing_Mark",
        Me: "Enclosing_Mark",
        N: "Number",
        Nd: "Decimal_Number",
        Nl: "Letter_Number",
        No: "Other_Number",
        P: "Punctuation",
        Pd: "Dash_Punctuation",
        Ps: "Open_Punctuation",
        Pe: "Close_Punctuation",
        Pi: "Initial_Punctuation",
        Pf: "Final_Punctuation",
        Pc: "Connector_Punctuation",
        Po: "Other_Punctuation",
        S: "Symbol",
        Sm: "Math_Symbol",
        Sc: "Currency_Symbol",
        Sk: "Modifier_Symbol",
        So: "Other_Symbol",
        Z: "Separator",
        Zs: "Space_Separator",
        Zl: "Line_Separator",
        Zp: "Paragraph_Separator",
        C: "Other",
        Cc: "Control",
        Cf: "Format",
        Co: "Private_Use",
        Cs: "Surrogate",
        Cn: "Unassigned"
    });

}(XRegExp));


/***** unicode-scripts.js *****/

/*!
 * XRegExp Unicode Scripts v1.2.0
 * (c) 2010-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds support for all Unicode scripts in the Basic Multilingual Plane (U+0000-U+FFFF).
 * E.g., `\p{Latin}`. Token names are case insensitive, and any spaces, hyphens, and underscores
 * are ignored.
 * @requires XRegExp, XRegExp Unicode Base
 */
(function (XRegExp) {
    "use strict";

    if (!XRegExp.addUnicodePackage) {
        throw new ReferenceError("Unicode Base must be loaded before Unicode Scripts");
    }

    XRegExp.install("extensibility");

    XRegExp.addUnicodePackage({
        Arabic: "0600-06040606-060B060D-061A061E0620-063F0641-064A0656-065E066A-066F0671-06DC06DE-06FF0750-077F08A008A2-08AC08E4-08FEFB50-FBC1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFCFE70-FE74FE76-FEFC",
        Armenian: "0531-05560559-055F0561-0587058A058FFB13-FB17",
        Balinese: "1B00-1B4B1B50-1B7C",
        Bamum: "A6A0-A6F7",
        Batak: "1BC0-1BF31BFC-1BFF",
        Bengali: "0981-09830985-098C098F09900993-09A809AA-09B009B209B6-09B909BC-09C409C709C809CB-09CE09D709DC09DD09DF-09E309E6-09FB",
        Bopomofo: "02EA02EB3105-312D31A0-31BA",
        Braille: "2800-28FF",
        Buginese: "1A00-1A1B1A1E1A1F",
        Buhid: "1740-1753",
        Canadian_Aboriginal: "1400-167F18B0-18F5",
        Cham: "AA00-AA36AA40-AA4DAA50-AA59AA5C-AA5F",
        Cherokee: "13A0-13F4",
        Common: "0000-0040005B-0060007B-00A900AB-00B900BB-00BF00D700F702B9-02DF02E5-02E902EC-02FF0374037E038503870589060C061B061F06400660-066906DD096409650E3F0FD5-0FD810FB16EB-16ED173517361802180318051CD31CE11CE9-1CEC1CEE-1CF31CF51CF62000-200B200E-2064206A-20702074-207E2080-208E20A0-20B92100-21252127-2129212C-21312133-214D214F-215F21892190-23F32400-24262440-244A2460-26FF2701-27FF2900-2B4C2B50-2B592E00-2E3B2FF0-2FFB3000-300430063008-30203030-3037303C-303F309B309C30A030FB30FC3190-319F31C0-31E33220-325F327F-32CF3358-33FF4DC0-4DFFA700-A721A788-A78AA830-A839FD3EFD3FFDFDFE10-FE19FE30-FE52FE54-FE66FE68-FE6BFEFFFF01-FF20FF3B-FF40FF5B-FF65FF70FF9EFF9FFFE0-FFE6FFE8-FFEEFFF9-FFFD",
        Coptic: "03E2-03EF2C80-2CF32CF9-2CFF",
        Cyrillic: "0400-04840487-05271D2B1D782DE0-2DFFA640-A697A69F",
        Devanagari: "0900-09500953-09630966-09770979-097FA8E0-A8FB",
        Ethiopic: "1200-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A135D-137C1380-13992D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDEAB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2E",
        Georgian: "10A0-10C510C710CD10D0-10FA10FC-10FF2D00-2D252D272D2D",
        Glagolitic: "2C00-2C2E2C30-2C5E",
        Greek: "0370-03730375-0377037A-037D038403860388-038A038C038E-03A103A3-03E103F0-03FF1D26-1D2A1D5D-1D611D66-1D6A1DBF1F00-1F151F18-1F1D1F20-1F451F48-1F4D1F50-1F571F591F5B1F5D1F5F-1F7D1F80-1FB41FB6-1FC41FC6-1FD31FD6-1FDB1FDD-1FEF1FF2-1FF41FF6-1FFE2126",
        Gujarati: "0A81-0A830A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABC-0AC50AC7-0AC90ACB-0ACD0AD00AE0-0AE30AE6-0AF1",
        Gurmukhi: "0A01-0A030A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A3C0A3E-0A420A470A480A4B-0A4D0A510A59-0A5C0A5E0A66-0A75",
        Han: "2E80-2E992E9B-2EF32F00-2FD5300530073021-30293038-303B3400-4DB54E00-9FCCF900-FA6DFA70-FAD9",
        Hangul: "1100-11FF302E302F3131-318E3200-321E3260-327EA960-A97CAC00-D7A3D7B0-D7C6D7CB-D7FBFFA0-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC",
        Hanunoo: "1720-1734",
        Hebrew: "0591-05C705D0-05EA05F0-05F4FB1D-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FB4F",
        Hiragana: "3041-3096309D-309F",
        Inherited: "0300-036F04850486064B-0655065F0670095109521CD0-1CD21CD4-1CE01CE2-1CE81CED1CF41DC0-1DE61DFC-1DFF200C200D20D0-20F0302A-302D3099309AFE00-FE0FFE20-FE26",
        Javanese: "A980-A9CDA9CF-A9D9A9DEA9DF",
        Kannada: "0C820C830C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBC-0CC40CC6-0CC80CCA-0CCD0CD50CD60CDE0CE0-0CE30CE6-0CEF0CF10CF2",
        Katakana: "30A1-30FA30FD-30FF31F0-31FF32D0-32FE3300-3357FF66-FF6FFF71-FF9D",
        Kayah_Li: "A900-A92F",
        Khmer: "1780-17DD17E0-17E917F0-17F919E0-19FF",
        Lao: "0E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB90EBB-0EBD0EC0-0EC40EC60EC8-0ECD0ED0-0ED90EDC-0EDF",
        Latin: "0041-005A0061-007A00AA00BA00C0-00D600D8-00F600F8-02B802E0-02E41D00-1D251D2C-1D5C1D62-1D651D6B-1D771D79-1DBE1E00-1EFF2071207F2090-209C212A212B2132214E2160-21882C60-2C7FA722-A787A78B-A78EA790-A793A7A0-A7AAA7F8-A7FFFB00-FB06FF21-FF3AFF41-FF5A",
        Lepcha: "1C00-1C371C3B-1C491C4D-1C4F",
        Limbu: "1900-191C1920-192B1930-193B19401944-194F",
        Lisu: "A4D0-A4FF",
        Malayalam: "0D020D030D05-0D0C0D0E-0D100D12-0D3A0D3D-0D440D46-0D480D4A-0D4E0D570D60-0D630D66-0D750D79-0D7F",
        Mandaic: "0840-085B085E",
        Meetei_Mayek: "AAE0-AAF6ABC0-ABEDABF0-ABF9",
        Mongolian: "1800180118041806-180E1810-18191820-18771880-18AA",
        Myanmar: "1000-109FAA60-AA7B",
        New_Tai_Lue: "1980-19AB19B0-19C919D0-19DA19DE19DF",
        Nko: "07C0-07FA",
        Ogham: "1680-169C",
        Ol_Chiki: "1C50-1C7F",
        Oriya: "0B01-0B030B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3C-0B440B470B480B4B-0B4D0B560B570B5C0B5D0B5F-0B630B66-0B77",
        Phags_Pa: "A840-A877",
        Rejang: "A930-A953A95F",
        Runic: "16A0-16EA16EE-16F0",
        Samaritan: "0800-082D0830-083E",
        Saurashtra: "A880-A8C4A8CE-A8D9",
        Sinhala: "0D820D830D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60DCA0DCF-0DD40DD60DD8-0DDF0DF2-0DF4",
        Sundanese: "1B80-1BBF1CC0-1CC7",
        Syloti_Nagri: "A800-A82B",
        Syriac: "0700-070D070F-074A074D-074F",
        Tagalog: "1700-170C170E-1714",
        Tagbanwa: "1760-176C176E-177017721773",
        Tai_Le: "1950-196D1970-1974",
        Tai_Tham: "1A20-1A5E1A60-1A7C1A7F-1A891A90-1A991AA0-1AAD",
        Tai_Viet: "AA80-AAC2AADB-AADF",
        Tamil: "0B820B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BBE-0BC20BC6-0BC80BCA-0BCD0BD00BD70BE6-0BFA",
        Telugu: "0C01-0C030C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D-0C440C46-0C480C4A-0C4D0C550C560C580C590C60-0C630C66-0C6F0C78-0C7F",
        Thaana: "0780-07B1",
        Thai: "0E01-0E3A0E40-0E5B",
        Tibetan: "0F00-0F470F49-0F6C0F71-0F970F99-0FBC0FBE-0FCC0FCE-0FD40FD90FDA",
        Tifinagh: "2D30-2D672D6F2D702D7F",
        Vai: "A500-A62B",
        Yi: "A000-A48CA490-A4C6"
    });

}(XRegExp));


/***** unicode-blocks.js *****/

/*!
 * XRegExp Unicode Blocks v1.2.0
 * (c) 2010-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds support for all Unicode blocks in the Basic Multilingual Plane (U+0000-U+FFFF). Unicode
 * blocks use the prefix "In". E.g., `\p{InBasicLatin}`. Token names are case insensitive, and any
 * spaces, hyphens, and underscores are ignored.
 * @requires XRegExp, XRegExp Unicode Base
 */
(function (XRegExp) {
    "use strict";

    if (!XRegExp.addUnicodePackage) {
        throw new ReferenceError("Unicode Base must be loaded before Unicode Blocks");
    }

    XRegExp.install("extensibility");

    XRegExp.addUnicodePackage({
        InBasic_Latin: "0000-007F",
        InLatin_1_Supplement: "0080-00FF",
        InLatin_Extended_A: "0100-017F",
        InLatin_Extended_B: "0180-024F",
        InIPA_Extensions: "0250-02AF",
        InSpacing_Modifier_Letters: "02B0-02FF",
        InCombining_Diacritical_Marks: "0300-036F",
        InGreek_and_Coptic: "0370-03FF",
        InCyrillic: "0400-04FF",
        InCyrillic_Supplement: "0500-052F",
        InArmenian: "0530-058F",
        InHebrew: "0590-05FF",
        InArabic: "0600-06FF",
        InSyriac: "0700-074F",
        InArabic_Supplement: "0750-077F",
        InThaana: "0780-07BF",
        InNKo: "07C0-07FF",
        InSamaritan: "0800-083F",
        InMandaic: "0840-085F",
        InArabic_Extended_A: "08A0-08FF",
        InDevanagari: "0900-097F",
        InBengali: "0980-09FF",
        InGurmukhi: "0A00-0A7F",
        InGujarati: "0A80-0AFF",
        InOriya: "0B00-0B7F",
        InTamil: "0B80-0BFF",
        InTelugu: "0C00-0C7F",
        InKannada: "0C80-0CFF",
        InMalayalam: "0D00-0D7F",
        InSinhala: "0D80-0DFF",
        InThai: "0E00-0E7F",
        InLao: "0E80-0EFF",
        InTibetan: "0F00-0FFF",
        InMyanmar: "1000-109F",
        InGeorgian: "10A0-10FF",
        InHangul_Jamo: "1100-11FF",
        InEthiopic: "1200-137F",
        InEthiopic_Supplement: "1380-139F",
        InCherokee: "13A0-13FF",
        InUnified_Canadian_Aboriginal_Syllabics: "1400-167F",
        InOgham: "1680-169F",
        InRunic: "16A0-16FF",
        InTagalog: "1700-171F",
        InHanunoo: "1720-173F",
        InBuhid: "1740-175F",
        InTagbanwa: "1760-177F",
        InKhmer: "1780-17FF",
        InMongolian: "1800-18AF",
        InUnified_Canadian_Aboriginal_Syllabics_Extended: "18B0-18FF",
        InLimbu: "1900-194F",
        InTai_Le: "1950-197F",
        InNew_Tai_Lue: "1980-19DF",
        InKhmer_Symbols: "19E0-19FF",
        InBuginese: "1A00-1A1F",
        InTai_Tham: "1A20-1AAF",
        InBalinese: "1B00-1B7F",
        InSundanese: "1B80-1BBF",
        InBatak: "1BC0-1BFF",
        InLepcha: "1C00-1C4F",
        InOl_Chiki: "1C50-1C7F",
        InSundanese_Supplement: "1CC0-1CCF",
        InVedic_Extensions: "1CD0-1CFF",
        InPhonetic_Extensions: "1D00-1D7F",
        InPhonetic_Extensions_Supplement: "1D80-1DBF",
        InCombining_Diacritical_Marks_Supplement: "1DC0-1DFF",
        InLatin_Extended_Additional: "1E00-1EFF",
        InGreek_Extended: "1F00-1FFF",
        InGeneral_Punctuation: "2000-206F",
        InSuperscripts_and_Subscripts: "2070-209F",
        InCurrency_Symbols: "20A0-20CF",
        InCombining_Diacritical_Marks_for_Symbols: "20D0-20FF",
        InLetterlike_Symbols: "2100-214F",
        InNumber_Forms: "2150-218F",
        InArrows: "2190-21FF",
        InMathematical_Operators: "2200-22FF",
        InMiscellaneous_Technical: "2300-23FF",
        InControl_Pictures: "2400-243F",
        InOptical_Character_Recognition: "2440-245F",
        InEnclosed_Alphanumerics: "2460-24FF",
        InBox_Drawing: "2500-257F",
        InBlock_Elements: "2580-259F",
        InGeometric_Shapes: "25A0-25FF",
        InMiscellaneous_Symbols: "2600-26FF",
        InDingbats: "2700-27BF",
        InMiscellaneous_Mathematical_Symbols_A: "27C0-27EF",
        InSupplemental_Arrows_A: "27F0-27FF",
        InBraille_Patterns: "2800-28FF",
        InSupplemental_Arrows_B: "2900-297F",
        InMiscellaneous_Mathematical_Symbols_B: "2980-29FF",
        InSupplemental_Mathematical_Operators: "2A00-2AFF",
        InMiscellaneous_Symbols_and_Arrows: "2B00-2BFF",
        InGlagolitic: "2C00-2C5F",
        InLatin_Extended_C: "2C60-2C7F",
        InCoptic: "2C80-2CFF",
        InGeorgian_Supplement: "2D00-2D2F",
        InTifinagh: "2D30-2D7F",
        InEthiopic_Extended: "2D80-2DDF",
        InCyrillic_Extended_A: "2DE0-2DFF",
        InSupplemental_Punctuation: "2E00-2E7F",
        InCJK_Radicals_Supplement: "2E80-2EFF",
        InKangxi_Radicals: "2F00-2FDF",
        InIdeographic_Description_Characters: "2FF0-2FFF",
        InCJK_Symbols_and_Punctuation: "3000-303F",
        InHiragana: "3040-309F",
        InKatakana: "30A0-30FF",
        InBopomofo: "3100-312F",
        InHangul_Compatibility_Jamo: "3130-318F",
        InKanbun: "3190-319F",
        InBopomofo_Extended: "31A0-31BF",
        InCJK_Strokes: "31C0-31EF",
        InKatakana_Phonetic_Extensions: "31F0-31FF",
        InEnclosed_CJK_Letters_and_Months: "3200-32FF",
        InCJK_Compatibility: "3300-33FF",
        InCJK_Unified_Ideographs_Extension_A: "3400-4DBF",
        InYijing_Hexagram_Symbols: "4DC0-4DFF",
        InCJK_Unified_Ideographs: "4E00-9FFF",
        InYi_Syllables: "A000-A48F",
        InYi_Radicals: "A490-A4CF",
        InLisu: "A4D0-A4FF",
        InVai: "A500-A63F",
        InCyrillic_Extended_B: "A640-A69F",
        InBamum: "A6A0-A6FF",
        InModifier_Tone_Letters: "A700-A71F",
        InLatin_Extended_D: "A720-A7FF",
        InSyloti_Nagri: "A800-A82F",
        InCommon_Indic_Number_Forms: "A830-A83F",
        InPhags_pa: "A840-A87F",
        InSaurashtra: "A880-A8DF",
        InDevanagari_Extended: "A8E0-A8FF",
        InKayah_Li: "A900-A92F",
        InRejang: "A930-A95F",
        InHangul_Jamo_Extended_A: "A960-A97F",
        InJavanese: "A980-A9DF",
        InCham: "AA00-AA5F",
        InMyanmar_Extended_A: "AA60-AA7F",
        InTai_Viet: "AA80-AADF",
        InMeetei_Mayek_Extensions: "AAE0-AAFF",
        InEthiopic_Extended_A: "AB00-AB2F",
        InMeetei_Mayek: "ABC0-ABFF",
        InHangul_Syllables: "AC00-D7AF",
        InHangul_Jamo_Extended_B: "D7B0-D7FF",
        InHigh_Surrogates: "D800-DB7F",
        InHigh_Private_Use_Surrogates: "DB80-DBFF",
        InLow_Surrogates: "DC00-DFFF",
        InPrivate_Use_Area: "E000-F8FF",
        InCJK_Compatibility_Ideographs: "F900-FAFF",
        InAlphabetic_Presentation_Forms: "FB00-FB4F",
        InArabic_Presentation_Forms_A: "FB50-FDFF",
        InVariation_Selectors: "FE00-FE0F",
        InVertical_Forms: "FE10-FE1F",
        InCombining_Half_Marks: "FE20-FE2F",
        InCJK_Compatibility_Forms: "FE30-FE4F",
        InSmall_Form_Variants: "FE50-FE6F",
        InArabic_Presentation_Forms_B: "FE70-FEFF",
        InHalfwidth_and_Fullwidth_Forms: "FF00-FFEF",
        InSpecials: "FFF0-FFFF"
    });

}(XRegExp));


/***** unicode-properties.js *****/

/*!
 * XRegExp Unicode Properties v1.0.0
 * (c) 2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds Unicode properties necessary to meet Level 1 Unicode support (detailed in UTS#18 RL1.2).
 * Includes code points from the Basic Multilingual Plane (U+0000-U+FFFF) only. Token names are
 * case insensitive, and any spaces, hyphens, and underscores are ignored.
 * @requires XRegExp, XRegExp Unicode Base
 */
(function (XRegExp) {
    "use strict";

    if (!XRegExp.addUnicodePackage) {
        throw new ReferenceError("Unicode Base must be loaded before Unicode Properties");
    }

    XRegExp.install("extensibility");

    XRegExp.addUnicodePackage({
        Alphabetic: "0041-005A0061-007A00AA00B500BA00C0-00D600D8-00F600F8-02C102C6-02D102E0-02E402EC02EE03450370-037403760377037A-037D03860388-038A038C038E-03A103A3-03F503F7-0481048A-05270531-055605590561-058705B0-05BD05BF05C105C205C405C505C705D0-05EA05F0-05F20610-061A0620-06570659-065F066E-06D306D5-06DC06E1-06E806ED-06EF06FA-06FC06FF0710-073F074D-07B107CA-07EA07F407F507FA0800-0817081A-082C0840-085808A008A2-08AC08E4-08E908F0-08FE0900-093B093D-094C094E-09500955-09630971-09770979-097F0981-09830985-098C098F09900993-09A809AA-09B009B209B6-09B909BD-09C409C709C809CB09CC09CE09D709DC09DD09DF-09E309F009F10A01-0A030A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A3E-0A420A470A480A4B0A4C0A510A59-0A5C0A5E0A70-0A750A81-0A830A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABD-0AC50AC7-0AC90ACB0ACC0AD00AE0-0AE30B01-0B030B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3D-0B440B470B480B4B0B4C0B560B570B5C0B5D0B5F-0B630B710B820B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BBE-0BC20BC6-0BC80BCA-0BCC0BD00BD70C01-0C030C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D-0C440C46-0C480C4A-0C4C0C550C560C580C590C60-0C630C820C830C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBD-0CC40CC6-0CC80CCA-0CCC0CD50CD60CDE0CE0-0CE30CF10CF20D020D030D05-0D0C0D0E-0D100D12-0D3A0D3D-0D440D46-0D480D4A-0D4C0D4E0D570D60-0D630D7A-0D7F0D820D830D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60DCF-0DD40DD60DD8-0DDF0DF20DF30E01-0E3A0E40-0E460E4D0E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB90EBB-0EBD0EC0-0EC40EC60ECD0EDC-0EDF0F000F40-0F470F49-0F6C0F71-0F810F88-0F970F99-0FBC1000-10361038103B-103F1050-10621065-1068106E-1086108E109C109D10A0-10C510C710CD10D0-10FA10FC-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A135F1380-138F13A0-13F41401-166C166F-167F1681-169A16A0-16EA16EE-16F01700-170C170E-17131720-17331740-17531760-176C176E-1770177217731780-17B317B6-17C817D717DC1820-18771880-18AA18B0-18F51900-191C1920-192B1930-19381950-196D1970-19741980-19AB19B0-19C91A00-1A1B1A20-1A5E1A61-1A741AA71B00-1B331B35-1B431B45-1B4B1B80-1BA91BAC-1BAF1BBA-1BE51BE7-1BF11C00-1C351C4D-1C4F1C5A-1C7D1CE9-1CEC1CEE-1CF31CF51CF61D00-1DBF1E00-1F151F18-1F1D1F20-1F451F48-1F4D1F50-1F571F591F5B1F5D1F5F-1F7D1F80-1FB41FB6-1FBC1FBE1FC2-1FC41FC6-1FCC1FD0-1FD31FD6-1FDB1FE0-1FEC1FF2-1FF41FF6-1FFC2071207F2090-209C21022107210A-211321152119-211D212421262128212A-212D212F-2139213C-213F2145-2149214E2160-218824B6-24E92C00-2C2E2C30-2C5E2C60-2CE42CEB-2CEE2CF22CF32D00-2D252D272D2D2D30-2D672D6F2D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE2DE0-2DFF2E2F3005-30073021-30293031-30353038-303C3041-3096309D-309F30A1-30FA30FC-30FF3105-312D3131-318E31A0-31BA31F0-31FF3400-4DB54E00-9FCCA000-A48CA4D0-A4FDA500-A60CA610-A61FA62AA62BA640-A66EA674-A67BA67F-A697A69F-A6EFA717-A71FA722-A788A78B-A78EA790-A793A7A0-A7AAA7F8-A801A803-A805A807-A80AA80C-A827A840-A873A880-A8C3A8F2-A8F7A8FBA90A-A92AA930-A952A960-A97CA980-A9B2A9B4-A9BFA9CFAA00-AA36AA40-AA4DAA60-AA76AA7AAA80-AABEAAC0AAC2AADB-AADDAAE0-AAEFAAF2-AAF5AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABEAAC00-D7A3D7B0-D7C6D7CB-D7FBF900-FA6DFA70-FAD9FB00-FB06FB13-FB17FB1D-FB28FB2A-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBB1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFBFE70-FE74FE76-FEFCFF21-FF3AFF41-FF5AFF66-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC",
        Uppercase: "0041-005A00C0-00D600D8-00DE01000102010401060108010A010C010E01100112011401160118011A011C011E01200122012401260128012A012C012E01300132013401360139013B013D013F0141014301450147014A014C014E01500152015401560158015A015C015E01600162016401660168016A016C016E017001720174017601780179017B017D018101820184018601870189-018B018E-0191019301940196-0198019C019D019F01A001A201A401A601A701A901AC01AE01AF01B1-01B301B501B701B801BC01C401C701CA01CD01CF01D101D301D501D701D901DB01DE01E001E201E401E601E801EA01EC01EE01F101F401F6-01F801FA01FC01FE02000202020402060208020A020C020E02100212021402160218021A021C021E02200222022402260228022A022C022E02300232023A023B023D023E02410243-02460248024A024C024E03700372037603860388-038A038C038E038F0391-03A103A3-03AB03CF03D2-03D403D803DA03DC03DE03E003E203E403E603E803EA03EC03EE03F403F703F903FA03FD-042F04600462046404660468046A046C046E04700472047404760478047A047C047E0480048A048C048E04900492049404960498049A049C049E04A004A204A404A604A804AA04AC04AE04B004B204B404B604B804BA04BC04BE04C004C104C304C504C704C904CB04CD04D004D204D404D604D804DA04DC04DE04E004E204E404E604E804EA04EC04EE04F004F204F404F604F804FA04FC04FE05000502050405060508050A050C050E05100512051405160518051A051C051E05200522052405260531-055610A0-10C510C710CD1E001E021E041E061E081E0A1E0C1E0E1E101E121E141E161E181E1A1E1C1E1E1E201E221E241E261E281E2A1E2C1E2E1E301E321E341E361E381E3A1E3C1E3E1E401E421E441E461E481E4A1E4C1E4E1E501E521E541E561E581E5A1E5C1E5E1E601E621E641E661E681E6A1E6C1E6E1E701E721E741E761E781E7A1E7C1E7E1E801E821E841E861E881E8A1E8C1E8E1E901E921E941E9E1EA01EA21EA41EA61EA81EAA1EAC1EAE1EB01EB21EB41EB61EB81EBA1EBC1EBE1EC01EC21EC41EC61EC81ECA1ECC1ECE1ED01ED21ED41ED61ED81EDA1EDC1EDE1EE01EE21EE41EE61EE81EEA1EEC1EEE1EF01EF21EF41EF61EF81EFA1EFC1EFE1F08-1F0F1F18-1F1D1F28-1F2F1F38-1F3F1F48-1F4D1F591F5B1F5D1F5F1F68-1F6F1FB8-1FBB1FC8-1FCB1FD8-1FDB1FE8-1FEC1FF8-1FFB21022107210B-210D2110-211221152119-211D212421262128212A-212D2130-2133213E213F21452160-216F218324B6-24CF2C00-2C2E2C602C62-2C642C672C692C6B2C6D-2C702C722C752C7E-2C802C822C842C862C882C8A2C8C2C8E2C902C922C942C962C982C9A2C9C2C9E2CA02CA22CA42CA62CA82CAA2CAC2CAE2CB02CB22CB42CB62CB82CBA2CBC2CBE2CC02CC22CC42CC62CC82CCA2CCC2CCE2CD02CD22CD42CD62CD82CDA2CDC2CDE2CE02CE22CEB2CED2CF2A640A642A644A646A648A64AA64CA64EA650A652A654A656A658A65AA65CA65EA660A662A664A666A668A66AA66CA680A682A684A686A688A68AA68CA68EA690A692A694A696A722A724A726A728A72AA72CA72EA732A734A736A738A73AA73CA73EA740A742A744A746A748A74AA74CA74EA750A752A754A756A758A75AA75CA75EA760A762A764A766A768A76AA76CA76EA779A77BA77DA77EA780A782A784A786A78BA78DA790A792A7A0A7A2A7A4A7A6A7A8A7AAFF21-FF3A",
        Lowercase: "0061-007A00AA00B500BA00DF-00F600F8-00FF01010103010501070109010B010D010F01110113011501170119011B011D011F01210123012501270129012B012D012F01310133013501370138013A013C013E014001420144014601480149014B014D014F01510153015501570159015B015D015F01610163016501670169016B016D016F0171017301750177017A017C017E-0180018301850188018C018D019201950199-019B019E01A101A301A501A801AA01AB01AD01B001B401B601B901BA01BD-01BF01C601C901CC01CE01D001D201D401D601D801DA01DC01DD01DF01E101E301E501E701E901EB01ED01EF01F001F301F501F901FB01FD01FF02010203020502070209020B020D020F02110213021502170219021B021D021F02210223022502270229022B022D022F02310233-0239023C023F0240024202470249024B024D024F-02930295-02B802C002C102E0-02E40345037103730377037A-037D039003AC-03CE03D003D103D5-03D703D903DB03DD03DF03E103E303E503E703E903EB03ED03EF-03F303F503F803FB03FC0430-045F04610463046504670469046B046D046F04710473047504770479047B047D047F0481048B048D048F04910493049504970499049B049D049F04A104A304A504A704A904AB04AD04AF04B104B304B504B704B904BB04BD04BF04C204C404C604C804CA04CC04CE04CF04D104D304D504D704D904DB04DD04DF04E104E304E504E704E904EB04ED04EF04F104F304F504F704F904FB04FD04FF05010503050505070509050B050D050F05110513051505170519051B051D051F05210523052505270561-05871D00-1DBF1E011E031E051E071E091E0B1E0D1E0F1E111E131E151E171E191E1B1E1D1E1F1E211E231E251E271E291E2B1E2D1E2F1E311E331E351E371E391E3B1E3D1E3F1E411E431E451E471E491E4B1E4D1E4F1E511E531E551E571E591E5B1E5D1E5F1E611E631E651E671E691E6B1E6D1E6F1E711E731E751E771E791E7B1E7D1E7F1E811E831E851E871E891E8B1E8D1E8F1E911E931E95-1E9D1E9F1EA11EA31EA51EA71EA91EAB1EAD1EAF1EB11EB31EB51EB71EB91EBB1EBD1EBF1EC11EC31EC51EC71EC91ECB1ECD1ECF1ED11ED31ED51ED71ED91EDB1EDD1EDF1EE11EE31EE51EE71EE91EEB1EED1EEF1EF11EF31EF51EF71EF91EFB1EFD1EFF-1F071F10-1F151F20-1F271F30-1F371F40-1F451F50-1F571F60-1F671F70-1F7D1F80-1F871F90-1F971FA0-1FA71FB0-1FB41FB61FB71FBE1FC2-1FC41FC61FC71FD0-1FD31FD61FD71FE0-1FE71FF2-1FF41FF61FF72071207F2090-209C210A210E210F2113212F21342139213C213D2146-2149214E2170-217F218424D0-24E92C30-2C5E2C612C652C662C682C6A2C6C2C712C732C742C76-2C7D2C812C832C852C872C892C8B2C8D2C8F2C912C932C952C972C992C9B2C9D2C9F2CA12CA32CA52CA72CA92CAB2CAD2CAF2CB12CB32CB52CB72CB92CBB2CBD2CBF2CC12CC32CC52CC72CC92CCB2CCD2CCF2CD12CD32CD52CD72CD92CDB2CDD2CDF2CE12CE32CE42CEC2CEE2CF32D00-2D252D272D2DA641A643A645A647A649A64BA64DA64FA651A653A655A657A659A65BA65DA65FA661A663A665A667A669A66BA66DA681A683A685A687A689A68BA68DA68FA691A693A695A697A723A725A727A729A72BA72DA72F-A731A733A735A737A739A73BA73DA73FA741A743A745A747A749A74BA74DA74FA751A753A755A757A759A75BA75DA75FA761A763A765A767A769A76BA76DA76F-A778A77AA77CA77FA781A783A785A787A78CA78EA791A793A7A1A7A3A7A5A7A7A7A9A7F8-A7FAFB00-FB06FB13-FB17FF41-FF5A",
        White_Space: "0009-000D0020008500A01680180E2000-200A20282029202F205F3000",
        Noncharacter_Code_Point: "FDD0-FDEFFFFEFFFF",
        Default_Ignorable_Code_Point: "00AD034F115F116017B417B5180B-180D200B-200F202A-202E2060-206F3164FE00-FE0FFEFFFFA0FFF0-FFF8",
        // \p{Any} matches a code unit. To match any code point via surrogate pairs, use (?:[\0-\uD7FF\uDC00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF])
        Any: "0000-FFFF", // \p{^Any} compiles to [^\u0000-\uFFFF]; [\p{^Any}] to []
        Ascii: "0000-007F",
        // \p{Assigned} is equivalent to \p{^Cn}
        //Assigned: XRegExp("[\\p{^Cn}]").source.replace(/[[\]]|\\u/g, "") // Negation inside a character class triggers inversion
        Assigned: "0000-0377037A-037E0384-038A038C038E-03A103A3-05270531-05560559-055F0561-05870589058A058F0591-05C705D0-05EA05F0-05F40600-06040606-061B061E-070D070F-074A074D-07B107C0-07FA0800-082D0830-083E0840-085B085E08A008A2-08AC08E4-08FE0900-09770979-097F0981-09830985-098C098F09900993-09A809AA-09B009B209B6-09B909BC-09C409C709C809CB-09CE09D709DC09DD09DF-09E309E6-09FB0A01-0A030A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A3C0A3E-0A420A470A480A4B-0A4D0A510A59-0A5C0A5E0A66-0A750A81-0A830A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABC-0AC50AC7-0AC90ACB-0ACD0AD00AE0-0AE30AE6-0AF10B01-0B030B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3C-0B440B470B480B4B-0B4D0B560B570B5C0B5D0B5F-0B630B66-0B770B820B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BBE-0BC20BC6-0BC80BCA-0BCD0BD00BD70BE6-0BFA0C01-0C030C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D-0C440C46-0C480C4A-0C4D0C550C560C580C590C60-0C630C66-0C6F0C78-0C7F0C820C830C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBC-0CC40CC6-0CC80CCA-0CCD0CD50CD60CDE0CE0-0CE30CE6-0CEF0CF10CF20D020D030D05-0D0C0D0E-0D100D12-0D3A0D3D-0D440D46-0D480D4A-0D4E0D570D60-0D630D66-0D750D79-0D7F0D820D830D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60DCA0DCF-0DD40DD60DD8-0DDF0DF2-0DF40E01-0E3A0E3F-0E5B0E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB90EBB-0EBD0EC0-0EC40EC60EC8-0ECD0ED0-0ED90EDC-0EDF0F00-0F470F49-0F6C0F71-0F970F99-0FBC0FBE-0FCC0FCE-0FDA1000-10C510C710CD10D0-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A135D-137C1380-139913A0-13F41400-169C16A0-16F01700-170C170E-17141720-17361740-17531760-176C176E-1770177217731780-17DD17E0-17E917F0-17F91800-180E1810-18191820-18771880-18AA18B0-18F51900-191C1920-192B1930-193B19401944-196D1970-19741980-19AB19B0-19C919D0-19DA19DE-1A1B1A1E-1A5E1A60-1A7C1A7F-1A891A90-1A991AA0-1AAD1B00-1B4B1B50-1B7C1B80-1BF31BFC-1C371C3B-1C491C4D-1C7F1CC0-1CC71CD0-1CF61D00-1DE61DFC-1F151F18-1F1D1F20-1F451F48-1F4D1F50-1F571F591F5B1F5D1F5F-1F7D1F80-1FB41FB6-1FC41FC6-1FD31FD6-1FDB1FDD-1FEF1FF2-1FF41FF6-1FFE2000-2064206A-20712074-208E2090-209C20A0-20B920D0-20F02100-21892190-23F32400-24262440-244A2460-26FF2701-2B4C2B50-2B592C00-2C2E2C30-2C5E2C60-2CF32CF9-2D252D272D2D2D30-2D672D6F2D702D7F-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE2DE0-2E3B2E80-2E992E9B-2EF32F00-2FD52FF0-2FFB3000-303F3041-30963099-30FF3105-312D3131-318E3190-31BA31C0-31E331F0-321E3220-32FE3300-4DB54DC0-9FCCA000-A48CA490-A4C6A4D0-A62BA640-A697A69F-A6F7A700-A78EA790-A793A7A0-A7AAA7F8-A82BA830-A839A840-A877A880-A8C4A8CE-A8D9A8E0-A8FBA900-A953A95F-A97CA980-A9CDA9CF-A9D9A9DEA9DFAA00-AA36AA40-AA4DAA50-AA59AA5C-AA7BAA80-AAC2AADB-AAF6AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABEDABF0-ABF9AC00-D7A3D7B0-D7C6D7CB-D7FBD800-FA6DFA70-FAD9FB00-FB06FB13-FB17FB1D-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBC1FBD3-FD3FFD50-FD8FFD92-FDC7FDF0-FDFDFE00-FE19FE20-FE26FE30-FE52FE54-FE66FE68-FE6BFE70-FE74FE76-FEFCFEFFFF01-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDCFFE0-FFE6FFE8-FFEEFFF9-FFFD"
    });

}(XRegExp));


/***** matchrecursive.js *****/

/*!
 * XRegExp.matchRecursive v0.2.0
 * (c) 2009-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 */

(function (XRegExp) {
    "use strict";

/**
 * Returns a match detail object composed of the provided values.
 * @private
 */
    function row(value, name, start, end) {
        return {value:value, name:name, start:start, end:end};
    }

/**
 * Returns an array of match strings between outermost left and right delimiters, or an array of
 * objects with detailed match parts and position data. An error is thrown if delimiters are
 * unbalanced within the data.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {String} left Left delimiter as an XRegExp pattern.
 * @param {String} right Right delimiter as an XRegExp pattern.
 * @param {String} [flags] Flags for the left and right delimiters. Use any of: `gimnsxy`.
 * @param {Object} [options] Lets you specify `valueNames` and `escapeChar` options.
 * @returns {Array} Array of matches, or an empty array.
 * @example
 *
 * // Basic usage
 * var str = '(t((e))s)t()(ing)';
 * XRegExp.matchRecursive(str, '\\(', '\\)', 'g');
 * // -> ['t((e))s', '', 'ing']
 *
 * // Extended information mode with valueNames
 * str = 'Here is <div> <div>an</div></div> example';
 * XRegExp.matchRecursive(str, '<div\\s*>', '</div>', 'gi', {
 *   valueNames: ['between', 'left', 'match', 'right']
 * });
 * // -> [
 * // {name: 'between', value: 'Here is ',       start: 0,  end: 8},
 * // {name: 'left',    value: '<div>',          start: 8,  end: 13},
 * // {name: 'match',   value: ' <div>an</div>', start: 13, end: 27},
 * // {name: 'right',   value: '</div>',         start: 27, end: 33},
 * // {name: 'between', value: ' example',       start: 33, end: 41}
 * // ]
 *
 * // Omitting unneeded parts with null valueNames, and using escapeChar
 * str = '...{1}\\{{function(x,y){return y+x;}}';
 * XRegExp.matchRecursive(str, '{', '}', 'g', {
 *   valueNames: ['literal', null, 'value', null],
 *   escapeChar: '\\'
 * });
 * // -> [
 * // {name: 'literal', value: '...', start: 0, end: 3},
 * // {name: 'value',   value: '1',   start: 4, end: 5},
 * // {name: 'literal', value: '\\{', start: 6, end: 8},
 * // {name: 'value',   value: 'function(x,y){return y+x;}', start: 9, end: 35}
 * // ]
 *
 * // Sticky mode via flag y
 * str = '<1><<<2>>><3>4<5>';
 * XRegExp.matchRecursive(str, '<', '>', 'gy');
 * // -> ['1', '<<2>>', '3']
 */
    XRegExp.matchRecursive = function (str, left, right, flags, options) {
        flags = flags || "";
        options = options || {};
        var global = flags.indexOf("g") > -1,
            sticky = flags.indexOf("y") > -1,
            basicFlags = flags.replace(/y/g, ""), // Flag y controlled internally
            escapeChar = options.escapeChar,
            vN = options.valueNames,
            output = [],
            openTokens = 0,
            delimStart = 0,
            delimEnd = 0,
            lastOuterEnd = 0,
            outerStart,
            innerStart,
            leftMatch,
            rightMatch,
            esc;
        left = XRegExp(left, basicFlags);
        right = XRegExp(right, basicFlags);

        if (escapeChar) {
            if (escapeChar.length > 1) {
                throw new SyntaxError("can't use more than one escape character");
            }
            escapeChar = XRegExp.escape(escapeChar);
            // Using XRegExp.union safely rewrites backreferences in `left` and `right`
            esc = new RegExp(
                "(?:" + escapeChar + "[\\S\\s]|(?:(?!" + XRegExp.union([left, right]).source + ")[^" + escapeChar + "])+)+",
                flags.replace(/[^im]+/g, "") // Flags gy not needed here; flags nsx handled by XRegExp
            );
        }

        while (true) {
            // If using an escape character, advance to the delimiter's next starting position,
            // skipping any escaped characters in between
            if (escapeChar) {
                delimEnd += (XRegExp.exec(str, esc, delimEnd, "sticky") || [""])[0].length;
            }
            leftMatch = XRegExp.exec(str, left, delimEnd);
            rightMatch = XRegExp.exec(str, right, delimEnd);
            // Keep the leftmost match only
            if (leftMatch && rightMatch) {
                if (leftMatch.index <= rightMatch.index) {
                    rightMatch = null;
                } else {
                    leftMatch = null;
                }
            }
            /* Paths (LM:leftMatch, RM:rightMatch, OT:openTokens):
            LM | RM | OT | Result
            1  | 0  | 1  | loop
            1  | 0  | 0  | loop
            0  | 1  | 1  | loop
            0  | 1  | 0  | throw
            0  | 0  | 1  | throw
            0  | 0  | 0  | break
            * Doesn't include the sticky mode special case
            * Loop ends after the first completed match if `!global` */
            if (leftMatch || rightMatch) {
                delimStart = (leftMatch || rightMatch).index;
                delimEnd = delimStart + (leftMatch || rightMatch)[0].length;
            } else if (!openTokens) {
                break;
            }
            if (sticky && !openTokens && delimStart > lastOuterEnd) {
                break;
            }
            if (leftMatch) {
                if (!openTokens) {
                    outerStart = delimStart;
                    innerStart = delimEnd;
                }
                ++openTokens;
            } else if (rightMatch && openTokens) {
                if (!--openTokens) {
                    if (vN) {
                        if (vN[0] && outerStart > lastOuterEnd) {
                            output.push(row(vN[0], str.slice(lastOuterEnd, outerStart), lastOuterEnd, outerStart));
                        }
                        if (vN[1]) {
                            output.push(row(vN[1], str.slice(outerStart, innerStart), outerStart, innerStart));
                        }
                        if (vN[2]) {
                            output.push(row(vN[2], str.slice(innerStart, delimStart), innerStart, delimStart));
                        }
                        if (vN[3]) {
                            output.push(row(vN[3], str.slice(delimStart, delimEnd), delimStart, delimEnd));
                        }
                    } else {
                        output.push(str.slice(innerStart, delimStart));
                    }
                    lastOuterEnd = delimEnd;
                    if (!global) {
                        break;
                    }
                }
            } else {
                throw new Error("string contains unbalanced delimiters");
            }
            // If the delimiter matched an empty string, avoid an infinite loop
            if (delimStart === delimEnd) {
                ++delimEnd;
            }
        }

        if (global && !sticky && vN && vN[0] && str.length > lastOuterEnd) {
            output.push(row(vN[0], str.slice(lastOuterEnd), lastOuterEnd, str.length));
        }

        return output;
    };

}(XRegExp));


/***** build.js *****/

/*!
 * XRegExp.build v0.1.0
 * (c) 2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Inspired by RegExp.create by Lea Verou <http://lea.verou.me/>
 */

(function (XRegExp) {
    "use strict";

    var subparts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g,
        parts = XRegExp.union([/\({{([\w$]+)}}\)|{{([\w$]+)}}/, subparts], "g");

/**
 * Strips a leading `^` and trailing unescaped `$`, if both are present.
 * @private
 * @param {String} pattern Pattern to process.
 * @returns {String} Pattern with edge anchors removed.
 */
    function deanchor(pattern) {
        var startAnchor = /^(?:\(\?:\))?\^/, // Leading `^` or `(?:)^` (handles /x cruft)
            endAnchor = /\$(?:\(\?:\))?$/; // Trailing `$` or `$(?:)` (handles /x cruft)
        if (endAnchor.test(pattern.replace(/\\[\s\S]/g, ""))) { // Ensure trailing `$` isn't escaped
            return pattern.replace(startAnchor, "").replace(endAnchor, "");
        }
        return pattern;
    }

/**
 * Converts the provided value to an XRegExp.
 * @private
 * @param {String|RegExp} value Value to convert.
 * @returns {RegExp} XRegExp object with XRegExp syntax applied.
 */
    function asXRegExp(value) {
        return XRegExp.isRegExp(value) ?
                (value.xregexp && !value.xregexp.isNative ? value : XRegExp(value.source)) :
                XRegExp(value);
    }

/**
 * Builds regexes using named subpatterns, for readability and pattern reuse. Backreferences in the
 * outer pattern and provided subpatterns are automatically renumbered to work correctly. Native
 * flags used by provided subpatterns are ignored in favor of the `flags` argument.
 * @memberOf XRegExp
 * @param {String} pattern XRegExp pattern using `{{name}}` for embedded subpatterns. Allows
 *   `({{name}})` as shorthand for `(?<name>{{name}})`. Patterns cannot be embedded within
 *   character classes.
 * @param {Object} subs Lookup object for named subpatterns. Values can be strings or regexes. A
 *   leading `^` and trailing unescaped `$` are stripped from subpatterns, if both are present.
 * @param {String} [flags] Any combination of XRegExp flags.
 * @returns {RegExp} Regex with interpolated subpatterns.
 * @example
 *
 * var time = XRegExp.build('(?x)^ {{hours}} ({{minutes}}) $', {
 *   hours: XRegExp.build('{{h12}} : | {{h24}}', {
 *     h12: /1[0-2]|0?[1-9]/,
 *     h24: /2[0-3]|[01][0-9]/
 *   }, 'x'),
 *   minutes: /^[0-5][0-9]$/
 * });
 * time.test('10:59'); // -> true
 * XRegExp.exec('10:59', time).minutes; // -> '59'
 */
    XRegExp.build = function (pattern, subs, flags) {
        var inlineFlags = /^\(\?([\w$]+)\)/.exec(pattern),
            data = {},
            numCaps = 0, // Caps is short for captures
            numPriorCaps,
            numOuterCaps = 0,
            outerCapsMap = [0],
            outerCapNames,
            sub,
            p;

        // Add flags within a leading mode modifier to the overall pattern's flags
        if (inlineFlags) {
            flags = flags || "";
            inlineFlags[1].replace(/./g, function (flag) {
                flags += (flags.indexOf(flag) > -1 ? "" : flag); // Don't add duplicates
            });
        }

        for (p in subs) {
            if (subs.hasOwnProperty(p)) {
                // Passing to XRegExp enables entended syntax for subpatterns provided as strings
                // and ensures independent validity, lest an unescaped `(`, `)`, `[`, or trailing
                // `\` breaks the `(?:)` wrapper. For subpatterns provided as regexes, it dies on
                // octals and adds the `xregexp` property, for simplicity
                sub = asXRegExp(subs[p]);
                // Deanchoring allows embedding independently useful anchored regexes. If you
                // really need to keep your anchors, double them (i.e., `^^...$$`)
                data[p] = {pattern: deanchor(sub.source), names: sub.xregexp.captureNames || []};
            }
        }

        // Passing to XRegExp dies on octals and ensures the outer pattern is independently valid;
        // helps keep this simple. Named captures will be put back
        pattern = asXRegExp(pattern);
        outerCapNames = pattern.xregexp.captureNames || [];
        pattern = pattern.source.replace(parts, function ($0, $1, $2, $3, $4) {
            var subName = $1 || $2, capName, intro;
            if (subName) { // Named subpattern
                if (!data.hasOwnProperty(subName)) {
                    throw new ReferenceError("undefined property " + $0);
                }
                if ($1) { // Named subpattern was wrapped in a capturing group
                    capName = outerCapNames[numOuterCaps];
                    outerCapsMap[++numOuterCaps] = ++numCaps;
                    // If it's a named group, preserve the name. Otherwise, use the subpattern name
                    // as the capture name
                    intro = "(?<" + (capName || subName) + ">";
                } else {
                    intro = "(?:";
                }
                numPriorCaps = numCaps;
                return intro + data[subName].pattern.replace(subparts, function (match, paren, backref) {
                    if (paren) { // Capturing group
                        capName = data[subName].names[numCaps - numPriorCaps];
                        ++numCaps;
                        if (capName) { // If the current capture has a name, preserve the name
                            return "(?<" + capName + ">";
                        }
                    } else if (backref) { // Backreference
                        return "\\" + (+backref + numPriorCaps); // Rewrite the backreference
                    }
                    return match;
                }) + ")";
            }
            if ($3) { // Capturing group
                capName = outerCapNames[numOuterCaps];
                outerCapsMap[++numOuterCaps] = ++numCaps;
                if (capName) { // If the current capture has a name, preserve the name
                    return "(?<" + capName + ">";
                }
            } else if ($4) { // Backreference
                return "\\" + outerCapsMap[+$4]; // Rewrite the backreference
            }
            return $0;
        });

        return XRegExp(pattern, flags);
    };

}(XRegExp));


/***** prototypes.js *****/

/*!
 * XRegExp Prototype Methods v1.0.0
 * (c) 2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 */

/**
 * Adds a collection of methods to `XRegExp.prototype`. RegExp objects copied by XRegExp are also
 * augmented with any `XRegExp.prototype` methods. Hence, the following work equivalently:
 *
 * XRegExp('[a-z]', 'ig').xexec('abc');
 * XRegExp(/[a-z]/ig).xexec('abc');
 * XRegExp.globalize(/[a-z]/i).xexec('abc');
 */
(function (XRegExp) {
    "use strict";

/**
 * Copy properties of `b` to `a`.
 * @private
 * @param {Object} a Object that will receive new properties.
 * @param {Object} b Object whose properties will be copied.
 */
    function extend(a, b) {
        for (var p in b) {
            if (b.hasOwnProperty(p)) {
                a[p] = b[p];
            }
        }
        //return a;
    }

    extend(XRegExp.prototype, {

/**
 * Implicitly calls the regex's `test` method with the first value in the provided arguments array.
 * @memberOf XRegExp.prototype
 * @param {*} context Ignored. Accepted only for congruity with `Function.prototype.apply`.
 * @param {Array} args Array with the string to search as its first value.
 * @returns {Boolean} Whether the regex matched the provided value.
 * @example
 *
 * XRegExp('[a-z]').apply(null, ['abc']); // -> true
 */
        apply: function (context, args) {
            return this.test(args[0]);
        },

/**
 * Implicitly calls the regex's `test` method with the provided string.
 * @memberOf XRegExp.prototype
 * @param {*} context Ignored. Accepted only for congruity with `Function.prototype.call`.
 * @param {String} str String to search.
 * @returns {Boolean} Whether the regex matched the provided value.
 * @example
 *
 * XRegExp('[a-z]').call(null, 'abc'); // -> true
 */
        call: function (context, str) {
            return this.test(str);
        },

/**
 * Implicitly calls {@link #XRegExp.forEach}.
 * @memberOf XRegExp.prototype
 * @example
 *
 * XRegExp('\\d').forEach('1a2345', function (match, i) {
 *   if (i % 2) this.push(+match[0]);
 * }, []);
 * // -> [2, 4]
 */
        forEach: function (str, callback, context) {
            return XRegExp.forEach(str, this, callback, context);
        },

/**
 * Implicitly calls {@link #XRegExp.globalize}.
 * @memberOf XRegExp.prototype
 * @example
 *
 * var globalCopy = XRegExp('regex').globalize();
 * globalCopy.global; // -> true
 */
        globalize: function () {
            return XRegExp.globalize(this);
        },

/**
 * Implicitly calls {@link #XRegExp.exec}.
 * @memberOf XRegExp.prototype
 * @example
 *
 * var match = XRegExp('U\\+(?<hex>[0-9A-F]{4})').xexec('U+2620');
 * match.hex; // -> '2620'
 */
        xexec: function (str, pos, sticky) {
            return XRegExp.exec(str, this, pos, sticky);
        },

/**
 * Implicitly calls {@link #XRegExp.test}.
 * @memberOf XRegExp.prototype
 * @example
 *
 * XRegExp('c').xtest('abc'); // -> true
 */
        xtest: function (str, pos, sticky) {
            return XRegExp.test(str, this, pos, sticky);
        }

    });

}(XRegExp));

// TinyColor v0.9.15
// https://github.com/bgrins/TinyColor
// 2013-07-04, Brian Grinstead, MIT License
(function(root){function tinycolor(color,opts){if(color=color?color:"",opts=opts||{},"object"==typeof color&&color.hasOwnProperty("_tc_id"))return color;var rgb=inputToRGB(color),r=rgb.r,g=rgb.g,b=rgb.b,a=rgb.a,roundA=mathRound(100*a)/100,format=opts.format||rgb.format;return 1>r&&(r=mathRound(r)),1>g&&(g=mathRound(g)),1>b&&(b=mathRound(b)),{ok:rgb.ok,format:format,_tc_id:tinyCounter++,alpha:a,toHsv:function(){var hsv=rgbToHsv(r,g,b);return{h:360*hsv.h,s:hsv.s,v:hsv.v,a:a}},toHsvString:function(){var hsv=rgbToHsv(r,g,b),h=mathRound(360*hsv.h),s=mathRound(100*hsv.s),v=mathRound(100*hsv.v);return 1==a?"hsv("+h+", "+s+"%, "+v+"%)":"hsva("+h+", "+s+"%, "+v+"%, "+roundA+")"},toHsl:function(){var hsl=rgbToHsl(r,g,b);return{h:360*hsl.h,s:hsl.s,l:hsl.l,a:a}},toHslString:function(){var hsl=rgbToHsl(r,g,b),h=mathRound(360*hsl.h),s=mathRound(100*hsl.s),l=mathRound(100*hsl.l);return 1==a?"hsl("+h+", "+s+"%, "+l+"%)":"hsla("+h+", "+s+"%, "+l+"%, "+roundA+")"},toHex:function(allow3Char){return rgbToHex(r,g,b,allow3Char)},toHexString:function(allow3Char){return"#"+rgbToHex(r,g,b,allow3Char)},toRgb:function(){return{r:mathRound(r),g:mathRound(g),b:mathRound(b),a:a}},toRgbString:function(){return 1==a?"rgb("+mathRound(r)+", "+mathRound(g)+", "+mathRound(b)+")":"rgba("+mathRound(r)+", "+mathRound(g)+", "+mathRound(b)+", "+roundA+")"},toPercentageRgb:function(){return{r:mathRound(100*bound01(r,255))+"%",g:mathRound(100*bound01(g,255))+"%",b:mathRound(100*bound01(b,255))+"%",a:a}},toPercentageRgbString:function(){return 1==a?"rgb("+mathRound(100*bound01(r,255))+"%, "+mathRound(100*bound01(g,255))+"%, "+mathRound(100*bound01(b,255))+"%)":"rgba("+mathRound(100*bound01(r,255))+"%, "+mathRound(100*bound01(g,255))+"%, "+mathRound(100*bound01(b,255))+"%, "+roundA+")"},toName:function(){return 0===a?"transparent":hexNames[rgbToHex(r,g,b,!0)]||!1},toFilter:function(secondColor){var hex=rgbToHex(r,g,b),secondHex=hex,alphaHex=Math.round(255*parseFloat(a)).toString(16),secondAlphaHex=alphaHex,gradientType=opts&&opts.gradientType?"GradientType = 1, ":"";if(secondColor){var s=tinycolor(secondColor);secondHex=s.toHex(),secondAlphaHex=Math.round(255*parseFloat(s.alpha)).toString(16)}return"progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr=#"+pad2(alphaHex)+hex+",endColorstr=#"+pad2(secondAlphaHex)+secondHex+")"},toString:function(format){var formatSet=!!format;format=format||this.format;var formattedString=!1,hasAlphaAndFormatNotSet=!formatSet&&1>a&&a>0,formatWithAlpha=hasAlphaAndFormatNotSet&&("hex"===format||"hex6"===format||"hex3"===format||"name"===format);return"rgb"===format&&(formattedString=this.toRgbString()),"prgb"===format&&(formattedString=this.toPercentageRgbString()),("hex"===format||"hex6"===format)&&(formattedString=this.toHexString()),"hex3"===format&&(formattedString=this.toHexString(!0)),"name"===format&&(formattedString=this.toName()),"hsl"===format&&(formattedString=this.toHslString()),"hsv"===format&&(formattedString=this.toHsvString()),formatWithAlpha?this.toRgbString():formattedString||this.toHexString()}}}function inputToRGB(color){var rgb={r:0,g:0,b:0},a=1,ok=!1,format=!1;return"string"==typeof color&&(color=stringInputToObject(color)),"object"==typeof color&&(color.hasOwnProperty("r")&&color.hasOwnProperty("g")&&color.hasOwnProperty("b")?(rgb=rgbToRgb(color.r,color.g,color.b),ok=!0,format="%"===(color.r+"").substr(-1)?"prgb":"rgb"):color.hasOwnProperty("h")&&color.hasOwnProperty("s")&&color.hasOwnProperty("v")?(color.s=convertToPercentage(color.s),color.v=convertToPercentage(color.v),rgb=hsvToRgb(color.h,color.s,color.v),ok=!0,format="hsv"):color.hasOwnProperty("h")&&color.hasOwnProperty("s")&&color.hasOwnProperty("l")&&(color.s=convertToPercentage(color.s),color.l=convertToPercentage(color.l),rgb=hslToRgb(color.h,color.s,color.l),ok=!0,format="hsl"),color.hasOwnProperty("a")&&(a=color.a)),a=parseFloat(a),(isNaN(a)||0>a||a>1)&&(a=1),{ok:ok,format:color.format||format,r:mathMin(255,mathMax(rgb.r,0)),g:mathMin(255,mathMax(rgb.g,0)),b:mathMin(255,mathMax(rgb.b,0)),a:a}}function rgbToRgb(r,g,b){return{r:255*bound01(r,255),g:255*bound01(g,255),b:255*bound01(b,255)}}function rgbToHsl(r,g,b){r=bound01(r,255),g=bound01(g,255),b=bound01(b,255);var h,s,max=mathMax(r,g,b),min=mathMin(r,g,b),l=(max+min)/2;if(max==min)h=s=0;else{var d=max-min;switch(s=l>.5?d/(2-max-min):d/(max+min),max){case r:h=(g-b)/d+(b>g?6:0);break;case g:h=(b-r)/d+2;break;case b:h=(r-g)/d+4}h/=6}return{h:h,s:s,l:l}}function hslToRgb(h,s,l){function hue2rgb(p,q,t){return 0>t&&(t+=1),t>1&&(t-=1),1/6>t?p+6*(q-p)*t:.5>t?q:2/3>t?p+6*(q-p)*(2/3-t):p}var r,g,b;if(h=bound01(h,360),s=bound01(s,100),l=bound01(l,100),0===s)r=g=b=l;else{var q=.5>l?l*(1+s):l+s-l*s,p=2*l-q;r=hue2rgb(p,q,h+1/3),g=hue2rgb(p,q,h),b=hue2rgb(p,q,h-1/3)}return{r:255*r,g:255*g,b:255*b}}function rgbToHsv(r,g,b){r=bound01(r,255),g=bound01(g,255),b=bound01(b,255);var h,s,max=mathMax(r,g,b),min=mathMin(r,g,b),v=max,d=max-min;if(s=0===max?0:d/max,max==min)h=0;else{switch(max){case r:h=(g-b)/d+(b>g?6:0);break;case g:h=(b-r)/d+2;break;case b:h=(r-g)/d+4}h/=6}return{h:h,s:s,v:v}}function hsvToRgb(h,s,v){h=6*bound01(h,360),s=bound01(s,100),v=bound01(v,100);var i=math.floor(h),f=h-i,p=v*(1-s),q=v*(1-f*s),t=v*(1-(1-f)*s),mod=i%6,r=[v,q,p,p,t,v][mod],g=[t,v,v,q,p,p][mod],b=[p,p,t,v,v,q][mod];return{r:255*r,g:255*g,b:255*b}}function rgbToHex(r,g,b,allow3Char){var hex=[pad2(mathRound(r).toString(16)),pad2(mathRound(g).toString(16)),pad2(mathRound(b).toString(16))];return allow3Char&&hex[0].charAt(0)==hex[0].charAt(1)&&hex[1].charAt(0)==hex[1].charAt(1)&&hex[2].charAt(0)==hex[2].charAt(1)?hex[0].charAt(0)+hex[1].charAt(0)+hex[2].charAt(0):hex.join("")}function flip(o){var flipped={};for(var i in o)o.hasOwnProperty(i)&&(flipped[o[i]]=i);return flipped}function bound01(n,max){isOnePointZero(n)&&(n="100%");var processPercent=isPercentage(n);return n=mathMin(max,mathMax(0,parseFloat(n))),processPercent&&(n=parseInt(n*max,10)/100),1e-6>math.abs(n-max)?1:n%max/parseFloat(max)}function clamp01(val){return mathMin(1,mathMax(0,val))}function parseHex(val){return parseInt(val,16)}function isOnePointZero(n){return"string"==typeof n&&-1!=n.indexOf(".")&&1===parseFloat(n)}function isPercentage(n){return"string"==typeof n&&-1!=n.indexOf("%")}function pad2(c){return 1==c.length?"0"+c:""+c}function convertToPercentage(n){return 1>=n&&(n=100*n+"%"),n}function stringInputToObject(color){color=color.replace(trimLeft,"").replace(trimRight,"").toLowerCase();var named=!1;if(names[color])color=names[color],named=!0;else if("transparent"==color)return{r:0,g:0,b:0,a:0,format:"name"};var match;return(match=matchers.rgb.exec(color))?{r:match[1],g:match[2],b:match[3]}:(match=matchers.rgba.exec(color))?{r:match[1],g:match[2],b:match[3],a:match[4]}:(match=matchers.hsl.exec(color))?{h:match[1],s:match[2],l:match[3]}:(match=matchers.hsla.exec(color))?{h:match[1],s:match[2],l:match[3],a:match[4]}:(match=matchers.hsv.exec(color))?{h:match[1],s:match[2],v:match[3]}:(match=matchers.hex6.exec(color))?{r:parseHex(match[1]),g:parseHex(match[2]),b:parseHex(match[3]),format:named?"name":"hex"}:(match=matchers.hex3.exec(color))?{r:parseHex(match[1]+""+match[1]),g:parseHex(match[2]+""+match[2]),b:parseHex(match[3]+""+match[3]),format:named?"name":"hex"}:!1}var trimLeft=/^[\s,#]+/,trimRight=/\s+$/,tinyCounter=0,math=Math,mathRound=math.round,mathMin=math.min,mathMax=math.max,mathRandom=math.random;tinycolor.fromRatio=function(color,opts){if("object"==typeof color){var newColor={};for(var i in color)color.hasOwnProperty(i)&&(newColor[i]="a"===i?color[i]:convertToPercentage(color[i]));color=newColor}return tinycolor(color,opts)},tinycolor.equals=function(color1,color2){return color1&&color2?tinycolor(color1).toRgbString()==tinycolor(color2).toRgbString():!1},tinycolor.random=function(){return tinycolor.fromRatio({r:mathRandom(),g:mathRandom(),b:mathRandom()})},tinycolor.desaturate=function(color,amount){amount=0===amount?0:amount||10;var hsl=tinycolor(color).toHsl();return hsl.s-=amount/100,hsl.s=clamp01(hsl.s),tinycolor(hsl)},tinycolor.saturate=function(color,amount){amount=0===amount?0:amount||10;var hsl=tinycolor(color).toHsl();return hsl.s+=amount/100,hsl.s=clamp01(hsl.s),tinycolor(hsl)},tinycolor.greyscale=function(color){return tinycolor.desaturate(color,100)},tinycolor.lighten=function(color,amount){amount=0===amount?0:amount||10;var hsl=tinycolor(color).toHsl();return hsl.l+=amount/100,hsl.l=clamp01(hsl.l),tinycolor(hsl)},tinycolor.darken=function(color,amount){amount=0===amount?0:amount||10;var hsl=tinycolor(color).toHsl();return hsl.l-=amount/100,hsl.l=clamp01(hsl.l),tinycolor(hsl)},tinycolor.complement=function(color){var hsl=tinycolor(color).toHsl();return hsl.h=(hsl.h+180)%360,tinycolor(hsl)},tinycolor.triad=function(color){var hsl=tinycolor(color).toHsl(),h=hsl.h;return[tinycolor(color),tinycolor({h:(h+120)%360,s:hsl.s,l:hsl.l}),tinycolor({h:(h+240)%360,s:hsl.s,l:hsl.l})]},tinycolor.tetrad=function(color){var hsl=tinycolor(color).toHsl(),h=hsl.h;return[tinycolor(color),tinycolor({h:(h+90)%360,s:hsl.s,l:hsl.l}),tinycolor({h:(h+180)%360,s:hsl.s,l:hsl.l}),tinycolor({h:(h+270)%360,s:hsl.s,l:hsl.l})]},tinycolor.splitcomplement=function(color){var hsl=tinycolor(color).toHsl(),h=hsl.h;return[tinycolor(color),tinycolor({h:(h+72)%360,s:hsl.s,l:hsl.l}),tinycolor({h:(h+216)%360,s:hsl.s,l:hsl.l})]},tinycolor.analogous=function(color,results,slices){results=results||6,slices=slices||30;var hsl=tinycolor(color).toHsl(),part=360/slices,ret=[tinycolor(color)];for(hsl.h=(hsl.h-(part*results>>1)+720)%360;--results;)hsl.h=(hsl.h+part)%360,ret.push(tinycolor(hsl));return ret},tinycolor.monochromatic=function(color,results){results=results||6;for(var hsv=tinycolor(color).toHsv(),h=hsv.h,s=hsv.s,v=hsv.v,ret=[],modification=1/results;results--;)ret.push(tinycolor({h:h,s:s,v:v})),v=(v+modification)%1;return ret},tinycolor.readability=function(color1,color2){var a=tinycolor(color1).toRgb(),b=tinycolor(color2).toRgb(),brightnessA=(299*a.r+587*a.g+114*a.b)/1e3,brightnessB=(299*b.r+587*b.g+114*b.b)/1e3,colorDiff=Math.max(a.r,b.r)-Math.min(a.r,b.r)+Math.max(a.g,b.g)-Math.min(a.g,b.g)+Math.max(a.b,b.b)-Math.min(a.b,b.b);return{brightness:Math.abs(brightnessA-brightnessB),color:colorDiff}},tinycolor.readable=function(color1,color2){var readability=tinycolor.readability(color1,color2);return readability.brightness>125&&readability.color>500},tinycolor.mostReadable=function(baseColor,colorList){for(var bestColor=null,bestScore=0,bestIsReadable=!1,i=0;colorList.length>i;i++){var readability=tinycolor.readability(baseColor,colorList[i]),readable=readability.brightness>125&&readability.color>500,score=3*(readability.brightness/125)+readability.color/500;(readable&&!bestIsReadable||readable&&bestIsReadable&&score>bestScore||!readable&&!bestIsReadable&&score>bestScore)&&(bestIsReadable=readable,bestScore=score,bestColor=tinycolor(colorList[i]))}return bestColor};var names=tinycolor.names={aliceblue:"f0f8ff",antiquewhite:"faebd7",aqua:"0ff",aquamarine:"7fffd4",azure:"f0ffff",beige:"f5f5dc",bisque:"ffe4c4",black:"000",blanchedalmond:"ffebcd",blue:"00f",blueviolet:"8a2be2",brown:"a52a2a",burlywood:"deb887",burntsienna:"ea7e5d",cadetblue:"5f9ea0",chartreuse:"7fff00",chocolate:"d2691e",coral:"ff7f50",cornflowerblue:"6495ed",cornsilk:"fff8dc",crimson:"dc143c",cyan:"0ff",darkblue:"00008b",darkcyan:"008b8b",darkgoldenrod:"b8860b",darkgray:"a9a9a9",darkgreen:"006400",darkgrey:"a9a9a9",darkkhaki:"bdb76b",darkmagenta:"8b008b",darkolivegreen:"556b2f",darkorange:"ff8c00",darkorchid:"9932cc",darkred:"8b0000",darksalmon:"e9967a",darkseagreen:"8fbc8f",darkslateblue:"483d8b",darkslategray:"2f4f4f",darkslategrey:"2f4f4f",darkturquoise:"00ced1",darkviolet:"9400d3",deeppink:"ff1493",deepskyblue:"00bfff",dimgray:"696969",dimgrey:"696969",dodgerblue:"1e90ff",firebrick:"b22222",floralwhite:"fffaf0",forestgreen:"228b22",fuchsia:"f0f",gainsboro:"dcdcdc",ghostwhite:"f8f8ff",gold:"ffd700",goldenrod:"daa520",gray:"808080",green:"008000",greenyellow:"adff2f",grey:"808080",honeydew:"f0fff0",hotpink:"ff69b4",indianred:"cd5c5c",indigo:"4b0082",ivory:"fffff0",khaki:"f0e68c",lavender:"e6e6fa",lavenderblush:"fff0f5",lawngreen:"7cfc00",lemonchiffon:"fffacd",lightblue:"add8e6",lightcoral:"f08080",lightcyan:"e0ffff",lightgoldenrodyellow:"fafad2",lightgray:"d3d3d3",lightgreen:"90ee90",lightgrey:"d3d3d3",lightpink:"ffb6c1",lightsalmon:"ffa07a",lightseagreen:"20b2aa",lightskyblue:"87cefa",lightslategray:"789",lightslategrey:"789",lightsteelblue:"b0c4de",lightyellow:"ffffe0",lime:"0f0",limegreen:"32cd32",linen:"faf0e6",magenta:"f0f",maroon:"800000",mediumaquamarine:"66cdaa",mediumblue:"0000cd",mediumorchid:"ba55d3",mediumpurple:"9370db",mediumseagreen:"3cb371",mediumslateblue:"7b68ee",mediumspringgreen:"00fa9a",mediumturquoise:"48d1cc",mediumvioletred:"c71585",midnightblue:"191970",mintcream:"f5fffa",mistyrose:"ffe4e1",moccasin:"ffe4b5",navajowhite:"ffdead",navy:"000080",oldlace:"fdf5e6",olive:"808000",olivedrab:"6b8e23",orange:"ffa500",orangered:"ff4500",orchid:"da70d6",palegoldenrod:"eee8aa",palegreen:"98fb98",paleturquoise:"afeeee",palevioletred:"db7093",papayawhip:"ffefd5",peachpuff:"ffdab9",peru:"cd853f",pink:"ffc0cb",plum:"dda0dd",powderblue:"b0e0e6",purple:"800080",red:"f00",rosybrown:"bc8f8f",royalblue:"4169e1",saddlebrown:"8b4513",salmon:"fa8072",sandybrown:"f4a460",seagreen:"2e8b57",seashell:"fff5ee",sienna:"a0522d",silver:"c0c0c0",skyblue:"87ceeb",slateblue:"6a5acd",slategray:"708090",slategrey:"708090",snow:"fffafa",springgreen:"00ff7f",steelblue:"4682b4",tan:"d2b48c",teal:"008080",thistle:"d8bfd8",tomato:"ff6347",turquoise:"40e0d0",violet:"ee82ee",wheat:"f5deb3",white:"fff",whitesmoke:"f5f5f5",yellow:"ff0",yellowgreen:"9acd32"},hexNames=tinycolor.hexNames=flip(names),matchers=function(){var CSS_INTEGER="[-\\+]?\\d+%?",CSS_NUMBER="[-\\+]?\\d*\\.\\d+%?",CSS_UNIT="(?:"+CSS_NUMBER+")|(?:"+CSS_INTEGER+")",PERMISSIVE_MATCH3="[\\s|\\(]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")\\s*\\)?",PERMISSIVE_MATCH4="[\\s|\\(]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")\\s*\\)?";return{rgb:RegExp("rgb"+PERMISSIVE_MATCH3),rgba:RegExp("rgba"+PERMISSIVE_MATCH4),hsl:RegExp("hsl"+PERMISSIVE_MATCH3),hsla:RegExp("hsla"+PERMISSIVE_MATCH4),hsv:RegExp("hsv"+PERMISSIVE_MATCH3),hex3:/^([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex6:/^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/}}();"undefined"!=typeof module&&module.exports?module.exports=tinycolor:"undefined"!=typeof define?define(function(){return tinycolor}):root.tinycolor=tinycolor})(this);
/*
    * Pick-a-Color JS v1.2.3
    * Copyright 2013 Lauren Sperber and Broadstreet Ads
    * https://github.com/lauren/pick-a-color/blob/master/LICENSE
*/
!function(o){"use strict";o.fn.pickAColor=function(t){void 0===t.touchOnlyMode&&(t.touchOnlyMode=!1);var e="ontouchstart"in window&&t.touchOnlyMode,a=(parseInt(o(window).width(),10)<767?!0:!1,"localStorage"in window&&null!==window.localStorage&&"object"==typeof JSON),n=document.all&&!window.atob,r=e?"touchstart.pickAColor":"mousedown.pickAColor",s=e?"touchmove.pickAColor":"mousemove.pickAColor",i=e?"touchend.pickAColor":"mouseup.pickAColor",l=e?"touchend.pickAColor":"click.pickAColor",d="dragging.pickAColor",c="endDrag.pickAColor",p=o.extend({showSpectrum:!0,showSavedColors:!0,saveColorsPerElement:!1,fadeMenuToggle:!0,showAdvanced:!0,showBasicColors:!0,showHexInput:!0,allowBlank:!1,inlineDropdown:!1,basicColors:{white:"fff",red:"f00",orange:"f60",yellow:"ff0",green:"008000",blue:"00f",purple:"800080",black:"000"}},t);p.showAdvanced||p.showBasicColors||(p.showBasicColors=!0);var u=p.showSavedColors&&p.showAdvanced||p.showBasicColors&&p.showSavedColors||p.showBasicColors&&p.showAdvanced,h=function(){var t=o("<div>").addClass("input-group-btn"),e=o("<button type='button'>").addClass("btn btn-default color-dropdown dropdown-toggle"),a=o("<span>").addClass("color-preview current-color"),r=o("<span>").addClass("caret"),s=o("<div>").addClass("color-menu dropdown-menu");if(p.inlineDropdown&&s.addClass("color-menu--inline"),p.showHexInput||(e.addClass("no-hex"),s.addClass("no-hex")),t.append(e.append(a).append(r)),u||p.showSpectrum||s.addClass("small"),u){var i=o("<div>").addClass("color-menu-tabs"),l=p.showBasicColors?"savedColors-tab tab":"savedColors-tab tab tab-active";p.showBasicColors&&i.append(o("<span>").addClass("basicColors-tab tab tab-active").append(o("<a>").text("Basic Colors"))),p.showSavedColors&&i.append(o("<span>").addClass(l).append(o("<a>").text("Saved Colors"))),p.showAdvanced&&i.append(o("<span>").addClass("advanced-tab tab").append(o("<a>").text("Advanced"))),s.append(i)}if(p.showBasicColors){var d=o("<div>").addClass("basicColors-content active-content");p.showSpectrum&&d.append(o("<h6>").addClass("color-menu-instructions").text("Tap spectrum or drag band to change color"));var c=o("<ul>").addClass("basic-colors-list");o.each(p.basicColors,function(t,e){var a=o("<li>").addClass("color-item"),r=o("<a>").addClass(t+" color-link"),s=o("<span>").addClass("color-preview "+t),i=o("<span>").addClass("color-label").text(t);if(r.append(s,i),s.append(),"#"!==e[0]&&(e="#"+e),s.css("background-color",e),p.showSpectrum){var l=o("<span>").addClass("color-box spectrum-"+t);n&&o.each([0,1],function(a){"fff"!==e&&"000"!==t&&l.append(o("<span>").addClass(t+"-spectrum-"+a+" ie-spectrum"))});var d=o("<span>").addClass("highlight-band");o.each([0,1,2],function(){d.append(o("<span>").addClass("highlight-band-stripe"))}),r.append(l.append(d))}c.append(a.append(r))}),s.append(d.append(c))}if(p.showSavedColors){var h=p.showBasicColors?"inactive-content":"active-content",g=o("<div>").addClass("savedColors-content").addClass(h);g.append(o("<p>").addClass("saved-colors-instructions").text("Type in a color or use the spectrums to lighten or darken an existing color.")),s.append(g)}if(p.showAdvanced){var v=p.showBasicColors||p.showSavedColors?"inactive-content":"active-content",f=o("<div>").addClass("advanced-content").addClass(v).append(o("<h6>").addClass("advanced-instructions").text("Tap spectrum or drag band to change color")),C=o("<ul>").addClass("advanced-list"),m=o("<li>").addClass("hue-item"),b=o("<span>").addClass("hue-text").text("Hue: ").append(o("<span>").addClass("hue-value").text("0")),w=o("<span>").addClass("color-box spectrum-hue");n&&o.each([0,1,2,3,4,5,6],function(t){w.append(o("<span>").addClass("hue-spectrum-"+t+" ie-spectrum hue"))});var S=o("<span>").addClass("highlight-band");o.each([0,1,2],function(){S.append(o("<span>").addClass("highlight-band-stripe"))}),C.append(m.append(b).append(w.append(S)));var y=o("<li>").addClass("lightness-item"),k=o("<span>").addClass("color-box spectrum-lightness"),x=o("<span>").addClass("lightness-text").text("Lightness: ").append(o("<span>").addClass("lightness-value").text("50%"));n&&o.each([0,1],function(t){k.append(o("<span>").addClass("lightness-spectrum-"+t+" ie-spectrum"))});var H=o("<span>").addClass("highlight-band");o.each([0,1,2],function(){H.append(o("<span>").addClass("highlight-band-stripe"))}),C.append(y.append(x).append(k.append(H)));var A=o("<li>").addClass("saturation-item"),B=o("<span>").addClass("color-box spectrum-saturation");n&&o.each([0,1],function(t){B.append(o("<span>").addClass("saturation-spectrum-"+t+" ie-spectrum"))});var M=o("<span>").addClass("highlight-band");o.each([0,1,2],function(){M.append(o("<span>").addClass("highlight-band-stripe"))});var I=o("<span>").addClass("saturation-text").text("Saturation: ").append(o("<span>").addClass("saturation-value").text("100%"));C.append(A.append(I).append(B.append(M)));var T=o("<li>").addClass("preview-item").append(o("<span>").addClass("preview-text").text("Preview")),P=o("<span>").addClass("color-preview advanced").append("<button class='color-select btn btn-mini advanced' type='button'>Select</button>");C.append(T.append(P)),s.append(f.append(C))}return t.append(s),t},g={},v={rowsInDropdown:8,maxColsInDropdown:2};if(p.showSavedColors){var f=[];if(a&&localStorage.allSavedColors)f=JSON.parse(localStorage.allSavedColors);else if(document.cookie.match("pickAColorSavedColors-allSavedColors=")){var C=document.cookie.split(";");o.each(C,function(o){C[o].match("pickAColorSavedColors-allSavedColors=")&&(f=C[o].split("=")[1].split(","))})}}var m={initialize:function(t){var e,a,n=o(this);n.attr("name")||n.attr("name","pick-a-color-"+t),a=n.attr("name"),n.addClass("pick-a-color"),p.allowBlank?n.val().match(/^\s+$|^$/)||(g.defaultColor=tinycolor(n.val()).toHex(),g.typedColor=g.defaultColor,n.val(g.defaultColor)):(g.defaultColor=tinycolor(n.val()).toHex(),g.typedColor=g.defaultColor,n.val(g.defaultColor)),o(n).wrap('<div class="input-group pick-a-color-markup" id="'+a+'">'),e=o(n.parent()),p.showHexInput?e.prepend('<span class="hex-pound input-group-addon">#</span>').append(h()):e.append(h()),p.showHexInput||n.attr("type","hidden")},updatePreview:function(o){p.allowBlank?(g.typedColor=o.val().match(/^\s+$|^$/)?"":tinycolor(o.val()).toHex(),""===g.typedColor?o.siblings(".input-group-btn").find(".current-color").css("background","none"):o.siblings(".input-group-btn").find(".current-color").css("background-color","#"+g.typedColor)):(g.typedColor=tinycolor(o.val()).toHex(),o.siblings(".input-group-btn").find(".current-color").css("background-color","#"+g.typedColor))},pressPreviewButton:function(){var o=arguments[0].thisEvent;o.stopPropagation(),m.toggleDropdown(o.target)},openDropdown:function(t,a){o(".color-menu").each(function(){var t=o(this);if("block"===t.css("display")){var e=t.parents(".input-group-btn");m.closeDropdown(e,t)}}),p.fadeMenuToggle&&!e?o(a).fadeIn("fast"):o(a).show(),o(t).addClass("open")},closeDropdown:function(t,a){p.fadeMenuToggle&&!e?o(a).fadeOut("fast"):o(a).css("display","none"),o(t).removeClass("open")},closeDropdownIfOpen:function(){var o=arguments[0].button,t=arguments[0].menu;"block"===t.css("display")&&m.closeDropdown(o,t)},toggleDropdown:function(t){var e=o(t).parents(".pick-a-color-markup"),a=e.find("input"),n=e.find(".input-group-btn"),r=e.find(".color-menu");a.is(":disabled")||"none"!==r.css("display")?m.closeDropdown(n,r):m.openDropdown(n,r)},tabbable:function(){var t=o(this),e=t.parents(".pick-a-color-markup");t.click(function(){var t=o(this),a=t.attr("class").split(" ")[0].split("-")[0]+"-content",n=t.parents(".dropdown-menu").find("."+a);t.hasClass("tab-active")||(e.find(".tab-active").removeClass("tab-active"),e.find(".active-content").removeClass("active-content").addClass("inactive-content"),t.addClass("tab-active"),o(n).addClass("active-content").removeClass("inactive-content"))})},getColorMultiplier:function(t,a,n){var r="basic"===n?parseInt(o(".color-box").first().width(),10):parseInt(o(".advanced-list").find(".color-box").first().width(),10);0===r&&(r="basic"===n?e?160:200:e?160:300);var s=r/2,i=a/r;return"bidirectional"===t?.5>=i?(1-a/s)/2:-((a-s)/s)/2:"darkenRight"===t?-(i/2):i/2},modifyHSLLightness:function(o,t){var e=o;return e.l+=t,e.l=Math.min(Math.max(0,e.l),1),tinycolor(e).toHslString()},getMoveableArea:function(o){var t={},e=o.parent(),a=o.outerWidth(),n=e.width(),r=e.offset();return t.minX=r.left,t.maxX=n-a,t},moveHighlightBand:function(t,a,n){var r=o(".highlight-band").first().outerWidth(),s=.75*r,i=e?n.originalEvent.pageX:n.pageX,l=i-a.minX-s;l=Math.max(0,Math.min(l,a.maxX)),t.css("position","absolute"),t.css("left",l)},horizontallyDraggable:function(){o(this).on(r,function(t){t.preventDefault();var e=o(t.delegateTarget);e.css("cursor","-webkit-grabbing"),e.css("cursor","-moz-grabbing");var a=m.getMoveableArea(e);o(document).on(s,function(o){e.trigger(d),m.moveHighlightBand(e,a,o)}).on(i,function(t){o(document).off(s),o(document).off(d),e.css("cursor","-webkit-grab"),e.css("cursor","-moz-grab"),e.trigger(c),o(document).off(i)})}).on(i,function(t){t.stopPropagation(),o(document).off(s),o(document).off(d)})},modifyHighlightBand:function(o,t,e){var a={h:0,s:0,l:.05},n={h:0,s:0,l:.5},r=-t,s=o.find(".highlight-band-stripe"),i="lightenRight"===e?m.modifyHSLLightness(n,r):m.modifyHSLLightness(a,r);o.css("border-color",i),s.css("background-color",i)},calculateHighlightedColor:function(){var t,e,a,n,r,s,i,l,d=o(this),c=d.parent(),u=o(".highlight-band").first().outerWidth(),h=u/2,g=arguments[0].type;if("basic"===g){var v=c.attr("class").split("-")[2],f=p.basicColors[v];switch(e=tinycolor(f).toHsl(),f){case"fff":t="darkenRight";break;case"000":t="lightenRight";break;default:t="bidirectional"}}else{var C=d.parents(".advanced-list");n=arguments[0].hsl.s,i=C.find(".spectrum-hue"),a=arguments[0].hsl.h,s=C.find(".spectrum-saturation"),l=C.find(".lightness-value"),r=C.find(".color-preview"),e={h:arguments[0].hsl.h,l:.5,s:arguments[0].hsl.s},t="bidirectional"}var b=parseInt(d.css("left"),10)+h,w=m.getColorMultiplier(t,b,g),S=m.modifyHSLLightness(e,w),y="#"+tinycolor(S).toHex(),k=S.split("(")[1].split(")")[0].split(",")[2],x=parseInt(k.split("%")[0],10)/100;return"basic"===g?(c.siblings(".color-preview").css("background-color",y),c.prev(".color-label").replaceWith('<button class="color-select btn btn-mini" type="button">Select</button>'),"darkenRight"!==t&&m.modifyHighlightBand(d,w,t)):(r.css("background-color",y),l.text(k),m.updateSaturationStyles(s,a,x),m.updateHueStyles(i,n,x),m.modifyHighlightBand(o(".advanced-content .highlight-band"),w,t)),"basic"===g?tinycolor(S).toHex():x},updateSavedColorPreview:function(t){o.each(t,function(e){var a=o(t[e]),n=a.attr("class");a.find(".color-preview").css("background-color",n)})},updateSavedColorMarkup:function(t,e){if(e=e?e:f,p.showSavedColors&&e.length>0){p.saveColorsPerElement||(t=o(".savedColors-content"),e=f);var a=v.rowsInDropdown*v.maxColsInDropdown;e=e.slice(0,a);var n=o("<ul>").addClass("saved-color-col 0"),r=o("<ul>").addClass("saved-color-col 1");o.each(e,function(t,e){var a=o("<li>").addClass("color-item"),s=o("<a>").addClass(e);s.append(o("<span>").addClass("color-preview")),s.append(o("<span>").addClass("color-label").text(e)),a.append(s),t%2===0?n.append(a):r.append(a)}),t.html(n),t.append(r);var s=o(t).find("a");m.updateSavedColorPreview(s)}},setSavedColorsCookie:function(o,t){var e=new Date,a=31536e7,n=new Date(e.getTime()+a);n=n.toGMTString(),"undefined"==typeof t?document.cookie="pickAColorSavedColors-allSavedColors="+o+";expires="+n:document.cookie="pickAColorSavedColors-"+t+"="+o+"; expires="+n},saveColorsToLocalStorage:function(o,t){if(a)if("undefined"==typeof t)try{localStorage.allSavedColors=JSON.stringify(o)}catch(e){localStorage.clear()}else try{localStorage["pickAColorSavedColors-"+t]=JSON.stringify(o)}catch(e){localStorage.clear()}else m.setSavedColorsCookie(o,t)},removeFromArray:function(t,e){-1!==o.inArray(e,t)&&t.splice(o.inArray(e,t),1)},updateSavedColors:function(o,t,e){m.removeFromArray(t,o),t.unshift(o),m.saveColorsToLocalStorage(t,e)},addToSavedColors:function(o,t,e){if(p.showSavedColors&&void 0!==o)if("#"!=o[0]&&(o="#"+o),m.updateSavedColors(o,f),p.saveColorsPerElement){var a=t.colors,n=t.dataAttr;m.updateSavedColors(o,a,n),m.updateSavedColorMarkup(e,a)}else m.updateSavedColorMarkup(e,f)},selectFromBasicColors:function(){var t=o(this).find("span:first").css("background-color"),e=arguments[0].els,a=arguments[0].savedColorsInfo;t=tinycolor(t).toHex(),o(e.thisEl).val(t),o(e.thisEl).trigger("change"),m.updatePreview(e.thisEl),m.addToSavedColors(t,a,e.savedColorsContent),m.closeDropdown(e.colorPreviewButton,e.colorMenu)},tapSpectrum:function(){var t=arguments[0].thisEvent,a=arguments[0].savedColorsInfo,n=arguments[0].els,r=arguments[0].mostRecentClick;t.stopPropagation();var s=o(this).find(".highlight-band"),i=m.getMoveableArea(s);e?m.moveHighlightBand(s,i,r):m.moveHighlightBand(s,i,t);var l=m.calculateHighlightedColor.apply(s,[{type:"basic"}]);m.addToSavedColors(l,a,n.savedColorsContent),n.touchInstructions.html("Press 'select' to choose this color")},executeUnlessScrolled:function(){var t,a,n=arguments[0].thisFunction,s=arguments[0].theseArguments;o(this).on(r,function(e){t=o(window).scrollTop(),a=e}).on(l,function(r){var i=t-o(window).scrollTop();return e&&Math.abs(i)>0?!1:(s.thisEvent=r,s.mostRecentClick=a,n.apply(o(this),[s]),void 0)})},updateSaturationStyles:function(t,e,a){var r=(100*a).toString()+"%",s="#"+tinycolor("hsl("+e+",0%,"+r).toHex(),i="#"+tinycolor("hsl("+e+",50%,"+r).toHex(),l="#"+tinycolor("hsl("+e+",100%,"+r).toHex(),d="",c=(o.each(["-webkit-linear-gradient","-o-linear-gradient"],function(o,t){d+="background-image: "+t+"(left, "+s+" 0%, "+i+" 50%, "+l+" 100%);"}),"progid:DXImageTransform.Microsoft.gradient(startColorstr='"+s+"', endColorstr='"+i+"', GradientType=1)"),p="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+i+"', endColorstr='"+l+"', GradientType=1)";if(d="background-image: -moz-linear-gradient(left center, "+s+" 0%, "+i+" 50%, "+l+" 100%);background-image: linear-gradient(to right, "+s+" 0%, "+i+" 50%, "+l+" 100%); background-image: -webkit-gradient(linear, left top, right top,color-stop(0, "+s+"),color-stop(0.5, "+i+"),color-stop(1, "+l+"));"+d,n){var u=o(t).find(".saturation-spectrum-0"),h=o(t).find(".saturation-spectrum-1");u.css("filter",c),h.css("filter",p)}else t.attr("style",d)},updateLightnessStyles:function(t,e,a){var r=(100*a).toString()+"%",s="#"+tinycolor("hsl("+e+","+r+",100%)").toHex(),i="#"+tinycolor("hsl("+e+","+r+",50%)").toHex(),l="#"+tinycolor("hsl("+e+","+r+",0%)").toHex(),d="",c=(o.each(["-webkit-linear-gradient","-o-linear-gradient"],function(o,t){d+="background-image: "+t+"(left, "+s+" 0%, "+i+" 50%, "+l+" 100%);"}),"progid:DXImageTransform.Microsoft.gradient(startColorstr='"+s+"', endColorstr='"+i+"', GradientType=1)"),p="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+i+"', endColorstr='"+l+"', GradientType=1)";if(d="background-image: -moz-linear-gradient(left center, "+s+" 0%, "+i+" 50%, "+l+" 100%); background-image: linear-gradient(to right, "+s+" 0%, "+i+" 50%, "+l+" 100%); background-image: -webkit-gradient(linear, left top, right top, color-stop(0, "+s+"), color-stop(0.5, "+i+"), color-stop(1, "+l+")); "+d,n){var u=o(t).find(".lightness-spectrum-0"),h=o(t).find(".lightness-spectrum-1");u.css("filter",c),h.css("filter",p)}else t.attr("style",d)},updateHueStyles:function(t,e,a){var r=(100*e).toString()+"%",s=(100*a).toString()+"%",i="#"+tinycolor("hsl(0,"+r+","+s+")").toHex(),l="#"+tinycolor("hsl(60,"+r+","+s+")").toHex(),d="#"+tinycolor("hsl(120,"+r+","+s+")").toHex(),c="#"+tinycolor("hsl(180,"+r+","+s+")").toHex(),p="#"+tinycolor("hsl(240,"+r+","+s+")").toHex(),u="#"+tinycolor("hsl(300,"+r+","+s+")").toHex(),h="#"+tinycolor("hsl(0,"+r+","+s+")").toHex(),g="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+i+"', endColorstr='"+l+"', GradientType=1)",v="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+l+"', endColorstr='"+d+"', GradientType=1)",f="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+d+"', endColorstr='"+c+"', GradientType=1)",C="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+c+"', endColorstr='"+p+"', GradientType=1)",m="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+p+"', endColorstr='"+u+"', GradientType=1)",b="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+u+"', endColorstr='"+h+"', GradientType=1)",w="";o.each(["-webkit-linear-gradient","-o-linear-gradient"],function(o,t){w+="background-image: "+t+"(left, "+i+" 0%, "+l+" 17%, "+d+" 24%, "+c+" 51%, "+p+" 68%, "+u+" 85%, "+h+" 100%);"});if(w+="background-image: -webkit-gradient(linear, left top, right top,color-stop(0%, "+i+"),color-stop(17%, "+l+"),color-stop(34%, "+d+"),color-stop(51%, "+c+"),color-stop(68%, "+p+"),color-stop(85%, "+u+"),color-stop(100%, "+h+"));background-image: linear-gradient(to right, "+i+" 0%, "+l+" 17%, "+d+" 24%,"+c+" 51%,"+p+" 68%,"+u+" 85%,"+h+" 100%); background-image: -moz-linear-gradient(left center, "+i+" 0%, "+l+" 17%, "+d+" 24%, "+c+" 51%, "+p+" 68%, "+u+" 85%, "+h+" 100%);",n){var S=o(t).find(".hue-spectrum-0"),y=o(t).find(".hue-spectrum-1"),k=o(t).find(".hue-spectrum-2"),x=o(t).find(".hue-spectrum-3"),H=o(t).find(".hue-spectrum-4"),A=o(t).find(".hue-spectrum-5");S.css("filter",g),y.css("filter",v),k.css("filter",f),x.css("filter",C),H.css("filter",m),A.css("filter",b)}else t.attr("style",w)},getHighlightedHue:function(){var t=o(this),a=t.outerWidth(),n=a/2,r=parseInt(t.css("left"),10)+n,s=t.parents(".advanced-list"),i=s.find(".color-preview"),l=s.find(".spectrum-lightness"),d=s.find(".spectrum-saturation"),c=parseInt(s.find(".color-box").first().width(),10),p=s.find(".hue-value"),u=arguments[0].l,h=arguments[0].s,g=(100*h).toString()+"%",v=(100*u).toString()+"%";0===c&&(c=e?160:300);var f=Math.floor(r/c*360),C="hsl("+f+","+g+","+v+")";return C="#"+tinycolor(C).toHex(),i.css("background-color",C),p.text(f),m.updateLightnessStyles(l,f,h),m.updateSaturationStyles(d,f,u),f},getHighlightedSaturation:function(){var t=o(this),a=t.outerWidth(),n=a/2,r=parseInt(t.css("left"),10)+n,s=t.parents(".advanced-list"),i=s.find(".color-preview"),l=s.find(".spectrum-lightness"),d=s.find(".spectrum-hue"),c=s.find(".saturation-value"),p=parseInt(s.find(".color-box").first().width(),10),u=arguments[0].l,h=(100*u).toString()+"%",g=arguments[0].h;0===p&&(p=e?160:300);var v=r/p,f=Math.round(100*v).toString()+"%",C="hsl("+g+","+f+","+h+")";return C="#"+tinycolor(C).toHex(),i.css("background-color",C),c.text(f),m.updateLightnessStyles(l,g,v),m.updateHueStyles(d,v,u),v},updateAdvancedInstructions:function(o){o.html("Press the color preview to choose this color")}};return this.each(function(t){m.initialize.apply(this,[t]);var e,n,r={thisEl:o(this),thisWrapper:o(this).parent(),colorTextInput:o(this).find("input"),colorMenuLinks:o(this).parent().find(".color-menu li a"),colorPreviewButton:o(this).parent().find(".input-group-btn"),colorMenu:o(this).parent().find(".color-menu"),colorSpectrums:o(this).parent().find(".color-box"),basicSpectrums:o(this).parent().find(".basicColors-content .color-box"),touchInstructions:o(this).parent().find(".color-menu-instructions"),advancedInstructions:o(this).parent().find(".advanced-instructions"),highlightBands:o(this).parent().find(".highlight-band"),basicHighlightBands:o(this).parent().find(".basicColors-content .highlight-band")};if(u&&(r.tabs=r.thisWrapper.find(".tab")),p.showSavedColors&&(r.savedColorsContent=r.thisWrapper.find(".savedColors-content"),p.saveColorsPerElement))if(n={colors:[],dataObj:o(this).data()},o.each(n.dataObj,function(o){n.dataAttr=o}),a&&localStorage["pickAColorSavedColors-"+n.dataAttr])n.colors=JSON.parse(localStorage["pickAColorSavedColors-"+n.dataAttr]);else if(document.cookie.match("pickAColorSavedColors-"+n.dataAttr))for(var s=document.cookie.split(";"),h=0;h<s.length;h++)s[h].match(n.dataAttr)&&(n.colors=s[h].split("=")[1].split(","));else n.colors=f;p.showAdvanced&&(e={h:0,s:1,l:.5},r.advancedSpectrums=r.thisWrapper.find(".advanced-list").find(".color-box"),r.advancedHighlightBands=r.thisWrapper.find(".advanced-list").find(".highlight-band"),r.hueSpectrum=r.thisWrapper.find(".spectrum-hue"),r.lightnessSpectrum=r.thisWrapper.find(".spectrum-lightness"),r.saturationSpectrum=r.thisWrapper.find(".spectrum-saturation"),r.hueHighlightBand=r.thisWrapper.find(".spectrum-hue .highlight-band"),r.lightnessHighlightBand=r.thisWrapper.find(".spectrum-lightness .highlight-band"),r.saturationHighlightBand=r.thisWrapper.find(".spectrum-saturation .highlight-band"),r.advancedPreview=r.thisWrapper.find(".advanced-content .color-preview")),m.addToSavedColors(g.defaultColor,n,r.savedColorsContent),m.updatePreview(r.thisEl),r.thisEl.focus(function(){var t=o(this);g.typedColor=t.val(),p.allowBlank||t.val(""),m.toggleDropdown(r.colorPreviewButton,r.ColorMenu)}).blur(function(){var t=o(this);g.newValue=t.val(),g.newValue.match(/^\s+$|^$/)?p.allowBlank||t.val(g.typedColor):(g.newValue=tinycolor(g.newValue).toHex(),t.val(g.newValue),m.addToSavedColors(g.newValue,n,r.savedColorsContent)),m.toggleDropdown(r.colorPreviewButton,r.ColorMenu),m.updatePreview(t)}),m.executeUnlessScrolled.apply(r.colorPreviewButton,[{thisFunction:m.pressPreviewButton,theseArguments:{}}]),m.executeUnlessScrolled.apply(o(document),[{thisFunction:m.closeDropdownIfOpen,theseArguments:{button:r.colorPreviewButton,menu:r.colorMenu}}]),r.colorMenu.on(l,function(o){o.stopPropagation()}),r.thisEl.on(l,function(o){o.stopPropagation()}),m.executeUnlessScrolled.apply(r.colorMenuLinks,[{thisFunction:m.selectFromBasicColors,theseArguments:{els:r,savedColorsInfo:n}}]),u&&m.tabbable.apply(r.tabs),(p.showSpectrum||p.showAdvanced)&&m.horizontallyDraggable.apply(r.highlightBands),p.showSpectrum&&(m.executeUnlessScrolled.apply(r.basicSpectrums,[{thisFunction:m.tapSpectrum,theseArguments:{savedColorsInfo:n,els:r}}]),o(r.basicHighlightBands).on(d,function(o){o.target;m.calculateHighlightedColor.apply(this,[{type:"basic"}])}).on(c,function(o){var t=o.delegateTarget,e=m.calculateHighlightedColor.apply(t,[{type:"basic"}]);m.addToSavedColors(e,n,r.savedColorsContent)})),p.showAdvanced&&(o(r.hueHighlightBand).on(d,function(o){e.h=m.getHighlightedHue.apply(this,[e])}),o(r.lightnessHighlightBand).on(d,function(){m.calculateHighlightedColor.apply(this,[{type:"advanced",hsl:e}])}).on(i,function(){e.l=m.calculateHighlightedColor.apply(this,[{type:"advanced",hsl:e}])}),o(r.saturationHighlightBand).on(d,function(){m.getHighlightedSaturation.apply(this,[e])}).on(c,function(){e.s=m.getHighlightedSaturation.apply(this,[e])}),o(r.advancedHighlightBand).on(c,function(){m.updateAdvancedInstructions(r.advancedInstructions)}),o(r.lightnessSpectrum).click(function(t){t.stopPropagation();var a=o(this).find(".highlight-band"),n=m.getMoveableArea(a);m.moveHighlightBand(a,n,t),e.l=m.calculateHighlightedColor.apply(a,[{type:"advanced",hsl:e}])}),o(r.hueSpectrum).click(function(t){t.stopPropagation();var a=o(this).find(".highlight-band"),n=m.getMoveableArea(a);m.moveHighlightBand(a,n,t),e.h=m.getHighlightedHue.apply(a,[e])}),o(r.saturationSpectrum).click(function(t){t.stopPropagation();var a=o(this).find(".highlight-band"),n=m.getMoveableArea(a);m.moveHighlightBand(a,n,t),e.s=m.getHighlightedSaturation.apply(a,[e])}),o(r.advancedSpectrums).click(function(){m.updateAdvancedInstructions(r.advancedInstructions)}),o(r.advancedPreview).click(function(){var t=tinycolor(o(this).css("background-color")).toHex();o(r.thisEl).val(t),o(r.thisEl).trigger("change"),m.updatePreview(r.thisEl),m.addToSavedColors(t,n,r.savedColorsContent),m.closeDropdown(r.colorPreviewButton,r.colorMenu)})),p.showSavedColors&&(o(r.savedColorsContent).click(function(t){var e=o(t.target);if(e.is("SPAN")||e.is("A")){var a=e.is("SPAN")?e.parent().attr("class").split("#")[1]:e.attr("class").split("#")[1];o(r.thisEl).val(a),o(r.thisEl).trigger("change"),m.updatePreview(r.thisEl),m.closeDropdown(r.colorPreviewButton,r.colorMenu),m.addToSavedColors(a,n,r.savedColorsContent)}}),p.saveColorsPerElement?p.saveColorsPerElement&&m.updateSavedColorMarkup(r.savedColorsContent,n.colors):m.updateSavedColorMarkup(r.savedColorsContent,f))})}}(jQuery);
/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

window.Form = window.Form || {};

Form.rte = Form.rte || {};

(function (ns) {

    var locale = "en";

    var I18n = ns.I18n = {};

    I18n.setLocale = function (value) {
        if (value) {
            if (value.indexOf("-") > -1) {
                var splitLocale = value.split("-");
                value = splitLocale[0].toLowerCase();
                if (splitLocale.length > 1) {
                    value += splitLocale[1].toUpperCase();  // if locale has country include that
                }
            }
            locale = value;
        }
    };

    I18n.get = function (str, snippets) {
        if (!str) {
            return "";
        }
        var localeFile = I18n[locale] || I18n.en;
        var strings = localeFile.strings || {};
        if (strings.hasOwnProperty(str)) {
            str = strings[str];
        }
        if (snippets && snippets.length > 0) {
            var pattern = /{(\d+)}/g;
            var result = pattern.exec(str);
            while (result) {
                str = str.replace(result[0], snippets[result[1]]);
                result = pattern.exec(str);
            }
        }
        return str;
    };
})(Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var en = I18n.en = {};

    en.strings = {
        "Undo" : "Undo",
        "Redo" : "Redo",
        "Bold" : "Bold",
        "Italic" : "Italic",
        "Underline" : "Underline",
        "Super-script" : "Super-script",
        "Sub-script" : "Sub-script",
        "Text Color" : "Text Color",
        "Highlight Color" : "Highlight Color",
        "Font Family" : "Font Family",
        "Font Size" : "Font Size",
        "Line Height" : "Line Height",
        "Letter Spacing" : "Letter Spacing",
        "Paragraph Format" : "Paragraph Format",
        "Justify Left" : "Justify Left",
        "Justify Center" : "Justify Center",
        "Justify Full" : "Justify Full",
        "Justify Right" : "Justify Right",
        "Margin Left" : "Margin Left",
        "Margin Right" : "Margin Right",
        "Margin Top" : "Margin Top",
        "Margin Bottom" : "Margin Bottom",
        "Bulleted List" : "Bulleted List",
        "Numbered List" : "Numbered List",
        "Upper-case Alphabet List" : "Upper-case Alphabet List",
        "Lower-case Alphabet List" : "Lower-case Alphabet List",
        "Upper-case Roman List" : "Upper-case Roman List",
        "Lower-case Roman List" : "Lower-case Roman List",
        "Indent" : "Indent",
        "Outdent" : "Outdent",
        "Find & Replace" : "Find & Replace",
        "Insert Link" : "Insert Link",
        "Find" : "Find",
        "Replace" : "Replace",
        "Replace all" : "Replace all",
        "Match case" : "Match case",
        "Whole word" : "Whole word",
        "Reg Ex" : "Reg Ex",
        "Info" : "Info",
        "Reached end of module." : "Reached end of module.",
        "Match Not Found" : "Match Not Found",
        "{0} matches replaced" : "{0} matches replaced",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "None",
        "Header 1" : "Header 1",
        "Header 2" : "Header 2",
        "Header 3" : "Header 3",
        "Header 4" : "Header 4",
        "Header 5" : "Header 5",
        "Header 6" : "Header 6",
        "Select" : "Select",
        "Basic View" : "Basic View",
        "FullScreen" : "FullScreen",
        "Expand" : "Expand",
        "Collapse" : "Collapse",
        "List Type" : "List Type",
        "URL" : "URL",
        "Alt Text" : "Alt Text",
        "Open in new page" : "Open in new page"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var de = I18n.de = {};

    de.strings = {
        "Undo" : "Rückgängig",
        "Redo" : "Wiederholen",
        "Bold" : "Fett",
        "Italic" : "Kursiv",
        "Underline" : "Unterstrichen",
        "Super-script" : "Hochgestellt",
        "Sub-script" : "Tiefgestellt",
        "Text Color" : "Textfarbe",
        "Highlight Color" : "Hervorhebungsfarbe",
        "Font Family" : "Schriftfamilie",
        "Font Size" : "Schriftgrad",
        "Line Height" : "Zeilenhöhe",
        "Letter Spacing" : "Buchstabenabstand",
        "Paragraph Format" : "Absatzformat",
        "Justify Left" : "Links ausrichten",
        "Justify Center" : "Zentriert ausrichten",
        "Justify Full" : "Blocksatz",
        "Justify Right" : "Rechts ausrichten",
        "Margin Left" : "Rand links",
        "Margin Right" : "Rand rechts",
        "Margin Top" : "Rand oben",
        "Margin Bottom" : "Rand unten",
        "Bulleted List" : "Liste mit Aufzählungszeichen",
        "Numbered List" : "Nummerierte Liste",
        "Upper-case Alphabet List" : "Alphabetliste mit Großbuchstaben",
        "Lower-case Alphabet List" : "Alphabetliste mit Kleinbuchstaben",
        "Upper-case Roman List" : "Liste mit großgeschriebenen römischen Zeichen",
        "Lower-case Roman List" : "Kleingeschriebene römische Liste",
        "Indent" : "Einzug",
        "Outdent" : "Ausrücken",
        "Find & Replace" : "Suchen und Ersetzen",
        "Insert Link" : "Link einfügen",
        "Find" : "Suchen",
        "Replace" : "Ersetzen",
        "Replace all" : "Alle ersetzen",
        "Match case" : "Groß-/Kleinschreibung beachten",
        "Whole word" : "Ganzes Wort",
        "Reg Ex" : "Regulärer Ausdruck",
        "Info" : "Information",
        "Reached end of module." : "Ende des Moduls wurde erreicht.",
        "Match Not Found" : "Keine Übereinstimmung gefunden",
        "{0} matches replaced" : "{0} Übereinstimmungen ersetzt",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Keine",
        "Header 1" : "Überschrift 1",
        "Header 2" : "Überschrift 2",
        "Header 3" : "Überschrift 3",
        "Header 4" : "Überschrift 4",
        "Header 5" : "Überschrift 5",
        "Header 6" : "Überschrift 6",
        "Select" : "Auswählen",
        "Basic View" : "Einfache Ansicht",
        "FullScreen" : "Vollbild",
        "Expand" : "Erweitern",
        "Collapse" : "Reduzieren",
        "List Type" : "Listentyp",
        "URL" : "URL",
        "Alt Text" : "Alt-Text",
        "Open in new page" : "Auf neuer Seite öffnen"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var es = I18n.es = {};

    es.strings = {
        "Undo" : "Deshacer",
        "Redo" : "Rehacer",
        "Bold" : "Negrita",
        "Italic" : "Cursiva",
        "Underline" : "Subrayado",
        "Super-script" : "Superíndice",
        "Sub-script" : "Subíndice",
        "Text Color" : "Color del texto",
        "Highlight Color" : "Color de resaltado",
        "Font Family" : "Familia de fuentes",
        "Font Size" : "Tamaño de fuente",
        "Line Height" : "Altura de la línea",
        "Letter Spacing" : "Espaciado entre letras",
        "Paragraph Format" : "Formato de párrafo",
        "Justify Left" : "Justificar a la izquierda",
        "Justify Center" : "Justificar al centro",
        "Justify Full" : "Justificar todo",
        "Justify Right" : "Justificar a la derecha",
        "Margin Left" : "Margen izquierdo",
        "Margin Right" : "Margen derecho",
        "Margin Top" : "Margen superior",
        "Margin Bottom" : "Margen inferior",
        "Bulleted List" : "Lista con viñetas",
        "Numbered List" : "Lista numerada",
        "Upper-case Alphabet List" : "Lista de letras del alfabeto en mayúscula",
        "Lower-case Alphabet List" : "Lista de letras del alfabeto en minúscula",
        "Upper-case Roman List" : "Lista de caracteres romanos en minúscula",
        "Lower-case Roman List" : "Lista de caracteres romanos en minúscula",
        "Indent" : "Sangría",
        "Outdent" : "Anular sangría",
        "Find & Replace" : "Buscar y reemplazar",
        "Insert Link" : "Insertar vínculo",
        "Find" : "Buscar",
        "Replace" : "Reemplazar",
        "Replace all" : "Reemplazar todo",
        "Match case" : "Coincidir mayúsculas y minúsculas",
        "Whole word" : "Palabra completa",
        "Reg Ex" : "Reg ex",
        "Info" : "Información",
        "Reached end of module." : "Fin del módulo alcanzado.",
        "Match Not Found" : "Coincidencia no encontrada",
        "{0} matches replaced" : "{0} coincidencias reemplazadas",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Ninguno",
        "Header 1" : "Cabecera 1",
        "Header 2" : "Cabecera 2",
        "Header 3" : "Cabecera 3",
        "Header 4" : "Cabecera 4",
        "Header 5" : "Cabecera 5",
        "Header 6" : "Cabecera 6",
        "Select" : "Seleccionar",
        "Basic View" : "Vista básica",
        "FullScreen" : "Pantalla completa",
        "Expand" : "Expandir",
        "Collapse" : "Contraer",
        "List Type" : "Tipo de lista",
        "URL" : "URL",
        "Alt Text" : "Texto alternativo",
        "Open in new page" : "Abrir en nueva página"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var fr = I18n.fr = {};

    fr.strings = {
        "Undo" : "Annuler",
        "Redo" : "Rétablir",
        "Bold" : "Gras",
        "Italic" : "Italique",
        "Underline" : "Souligné",
        "Super-script" : "Exposant",
        "Sub-script" : "Indice",
        "Text Color" : "Couleur du texte",
        "Highlight Color" : "Couleur de surbrillance",
        "Font Family" : "Famille de polices",
        "Font Size" : "Taille de la police",
        "Line Height" : "Hauteur de ligne",
        "Letter Spacing" : "Interlettrage",
        "Paragraph Format" : "Format de paragraphe",
        "Justify Left" : "Justifier à gauche",
        "Justify Center" : "Justifier au centre",
        "Justify Full" : "Justifier entièrement",
        "Justify Right" : "Justifier à droite",
        "Margin Left" : "Marge gauche",
        "Margin Right" : "Marge droite",
        "Margin Top" : "Marge supérieure",
        "Margin Bottom" : "Marge inférieure",
        "Bulleted List" : "Liste à puces",
        "Numbered List" : "Liste numérotée",
        "Upper-case Alphabet List" : "Liste alphabétique en majuscules",
        "Lower-case Alphabet List" : "Liste alphabétique en minuscules",
        "Upper-case Roman List" : "Liste en majuscules romaines",
        "Lower-case Roman List" : "Liste en caractères romains minuscules",
        "Indent" : "Retrait",
        "Outdent" : "Retrait négatif",
        "Find & Replace" : "Rechercher et remplacer",
        "Insert Link" : "Insérer un lien",
        "Find" : "Recherche",
        "Replace" : "Remplacer",
        "Replace all" : "Remplacer tout",
        "Match case" : "Respecter la casse",
        "Whole word" : "Mot entier",
        "Reg Ex" : "Exp. rég.",
        "Info" : "Infos",
        "Reached end of module." : "Atteindre la fin du module.",
        "Match Not Found" : "Aucune correspondance trouvée",
        "{0} matches replaced" : "{0} correspondances remplacées",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Aucune",
        "Header 1" : "En-tête 1",
        "Header 2" : "En-tête 2",
        "Header 3" : "En-tête 3",
        "Header 4" : "En-tête 4",
        "Header 5" : "En-tête 5",
        "Header 6" : "En-tête 6",
        "Select" : "Sélectionner",
        "Basic View" : "Vue de base",
        "FullScreen" : "Plein écran",
        "Expand" : "Développer",
        "Collapse" : "Réduire",
        "List Type" : "Type de liste",
        "URL" : "URL",
        "Alt Text" : "Autre texte",
        "Open in new page" : "Ouvrir dans une nouvelle page"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var it = I18n.it = {};

    it.strings = {
        "Undo" : "Annulla",
        "Redo" : "Ripeti",
        "Bold" : "Grassetto",
        "Italic" : "Corsivo",
        "Underline" : "Sottolinea",
        "Super-script" : "Apice",
        "Sub-script" : "Pedice",
        "Text Color" : "Colore testo",
        "Highlight Color" : "Colore evidenziazione",
        "Font Family" : "Famiglia di font",
        "Font Size" : "Dimensione font",
        "Line Height" : "Altezza riga",
        "Letter Spacing" : "Spaziatura tra lettere",
        "Paragraph Format" : "Formato paragrafo",
        "Justify Left" : "Giustifica a sinistra",
        "Justify Center" : "Giustifica al centro",
        "Justify Full" : "Giustifica",
        "Justify Right" : "Giustifica a destra",
        "Margin Left" : "Margine sinistro",
        "Margin Right" : "Margine destro",
        "Margin Top" : "Margine superiore",
        "Margin Bottom" : "Margine inferiore",
        "Bulleted List" : "Elenco puntato",
        "Numbered List" : "Elenco numerato",
        "Upper-case Alphabet List" : "Elenco alfabeto maiuscolo",
        "Lower-case Alphabet List" : "Elenco alfabeto minuscolo",
        "Upper-case Roman List" : "Elenco Roman maiuscolo",
        "Lower-case Roman List" : "Elenco Roman minuscolo",
        "Indent" : "Rientro",
        "Outdent" : "Rientro negativo",
        "Find & Replace" : "Trova e sostituisci",
        "Insert Link" : "Inserisci collegamento",
        "Find" : "Trova",
        "Replace" : "Sostituisci",
        "Replace all" : "Sostituisci tutto",
        "Match case" : "Maiuscole/minuscole",
        "Whole word" : "Parola intera",
        "Reg Ex" : "Reg eseg",
        "Info" : "Informazioni",
        "Reached end of module." : "Fine del modulo.",
        "Match Not Found" : "Corrispondenza non trovata",
        "{0} matches replaced" : "{0} corrispondenze sostituite",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Nessuno",
        "Header 1" : "Intestazione 1",
        "Header 2" : "Intestazione 2",
        "Header 3" : "Intestazione 3",
        "Header 4" : "Intestazione 4",
        "Header 5" : "Intestazione 5",
        "Header 6" : "Intestazione 6",
        "Select" : "Seleziona",
        "Basic View" : "Vista di base",
        "FullScreen" : "Schermo intero",
        "Expand" : "Espandi",
        "Collapse" : "Comprimi",
        "List Type" : "Tipo di lista",
        "URL" : "URL",
        "Alt Text" : "Testo alternativo",
        "Open in new page" : "Apri in nuova pagina"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var ja = I18n.ja = {};

    ja.strings = {
        "Undo" : "取り消し",
        "Redo" : "やり直し",
        "Bold" : "太字",
        "Italic" : "イタリック",
        "Underline" : "下線",
        "Super-script" : "上付き文字",
        "Sub-script" : "下付き文字",
        "Text Color" : "テキストカラー",
        "Highlight Color" : "ハイライト表示の色",
        "Font Family" : "フォントファミリー",
        "Font Size" : "フォントサイズ",
        "Line Height" : "行の高さ",
        "Letter Spacing" : "文字間隔",
        "Paragraph Format" : "段落書式",
        "Justify Left" : "左揃え",
        "Justify Center" : "中央揃え",
        "Justify Full" : "両端揃え",
        "Justify Right" : "右揃え",
        "Margin Left" : "左マージン",
        "Margin Right" : "右マージン",
        "Margin Top" : "上マージン",
        "Margin Bottom" : "下マージン",
        "Bulleted List" : "バレットリスト",
        "Numbered List" : "番号付きリスト",
        "Upper-case Alphabet List" : "大文字アルファベットリスト",
        "Lower-case Alphabet List" : "小文字アルファベットリスト",
        "Upper-case Roman List" : "大文字ローマンリスト",
        "Lower-case Roman List" : "小文字ローマンリスト",
        "Indent" : "インデント",
        "Outdent" : "アウトデント",
        "Find & Replace" : "検索と置換",
        "Insert Link" : "リンクを挿入",
        "Find" : "検索",
        "Replace" : "置換",
        "Replace all" : "すべて置換",
        "Match case" : "大文字 / 小文字を一致",
        "Whole word" : "単語全体",
        "Reg Ex" : "正規表現",
        "Info" : "情報",
        "Reached end of module." : "モジュールの最後に達しました。",
        "Match Not Found" : "一致が見つかりませんでした",
        "{0} matches replaced" : "{0} 個の一致が置換されました",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "適用なし",
        "Header 1" : "ヘッダー 1",
        "Header 2" : "ヘッダー 2",
        "Header 3" : "ヘッダー 3",
        "Header 4" : "ヘッダー 4",
        "Header 5" : "ヘッダー 5",
        "Header 6" : "ヘッダー 6",
        "Select" : "選択",
        "Basic View" : "基本表示",
        "FullScreen" : "フルスクリーン",
        "Expand" : "展開",
        "Collapse" : "隠す",
        "List Type" : "リストタイプ",
        "URL" : "URL",
        "Alt Text" : "代替テキスト",
        "Open in new page" : "新しいページで開く"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var koKR = I18n.koKR = {};

    koKR.strings = {
        "Undo" : "실행 취소",
        "Redo" : "다시 실행",
        "Bold" : "볼드체",
        "Italic" : "이탤릭체",
        "Underline" : "밑줄",
        "Super-script" : "위 첨자",
        "Sub-script" : "아래 첨자",
        "Text Color" : "텍스트 색상",
        "Highlight Color" : "강조 색상",
        "Font Family" : "글꼴 모음",
        "Font Size" : "글꼴 크기",
        "Line Height" : "선 높이",
        "Letter Spacing" : "문자 간격",
        "Paragraph Format" : "단락 형식",
        "Justify Left" : "왼쪽 맞춤",
        "Justify Center" : "가운데 맞춤",
        "Justify Full" : "전체 맞춤",
        "Justify Right" : "오른쪽 맞춤",
        "Margin Left" : "왼쪽 여백",
        "Margin Right" : "오른쪽 여백",
        "Margin Top" : "상단 여백",
        "Margin Bottom" : "하단 여백",
        "Bulleted List" : "글머리 기호 목록",
        "Numbered List" : "번호 매기기 목록",
        "Upper-case Alphabet List" : "대문자 알파벳 목록",
        "Lower-case Alphabet List" : "소문자 알파벳 목록",
        "Upper-case Roman List" : "대문자 로마자 목록",
        "Lower-case Roman List" : "소문자 로마자 목록",
        "Indent" : "들여쓰기",
        "Outdent" : "내어쓰기",
        "Find & Replace" : "찾기 및 바꾸기",
        "Insert Link" : "링크 삽입",
        "Find" : "찾기",
        "Replace" : "바꾸기",
        "Replace all" : "모두 바꾸기",
        "Match case" : "대소문자 일치",
        "Whole word" : "단어 단위로만",
        "Reg Ex" : "일반 표현식",
        "Info" : "정보",
        "Reached end of module." : "모듈 끝에 도달했습니다.",
        "Match Not Found" : "일치하는 항목을 찾을 수 없습니다.",
        "{0} matches replaced" : "{0}개의 일치 항목이 대체되었습니다.",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "없음",
        "Header 1" : "머리글 1",
        "Header 2" : "머리글 2",
        "Header 3" : "머리글 3",
        "Header 4" : "머리글 4",
        "Header 5" : "머리글 5",
        "Header 6" : "머리글 6",
        "Select" : "선택",
        "Basic View" : "기본 뷰",
        "FullScreen" : "전체화면",
        "Expand" : "확장",
        "Collapse" : "축소",
        "List Type" : "목록 유형",
        "URL" : "URL",
        "Alt Text" : "Alt 속성",
        "Open in new page" : "새 페이지에서 열기"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var ptBR = I18n.ptBR = {};

    ptBR.strings = {
        "Undo" : "Desfazer",
        "Redo" : "Refazer",
        "Bold" : "Negrito",
        "Italic" : "Itálico",
        "Underline" : "Sublinhado",
        "Super-script" : "Sobrescrito",
        "Sub-script" : "Subscrito",
        "Text Color" : "Cor do texto",
        "Highlight Color" : "Cor de realce",
        "Font Family" : "Família de fontes",
        "Font Size" : "Tamanho da fonte",
        "Line Height" : "Altura da linha",
        "Letter Spacing" : "Espaçamento entre Letras",
        "Paragraph Format" : "Formato de parágrafo",
        "Justify Left" : "Justificar à esquerda",
        "Justify Center" : "Justificar no centro",
        "Justify Full" : "Justificar tudo",
        "Justify Right" : "Justificar à direita",
        "Margin Left" : "Margem esquerda",
        "Margin Right" : "Margem direita",
        "Margin Top" : "Margem superior",
        "Margin Bottom" : "Margem inferior",
        "Bulleted List" : "Lista com marcadores",
        "Numbered List" : "Lista numerada",
        "Upper-case Alphabet List" : "Lista alfabética em maiúsculas",
        "Lower-case Alphabet List" : "Lista alfabética em minúsculas",
        "Upper-case Roman List" : "Lista de algarismos romanos maiúsculos",
        "Lower-case Roman List" : "Algarismos Romanos Minúsculos",
        "Indent" : "Recuo",
        "Outdent" : "Recuo para a esquerda",
        "Find & Replace" : "Localizar e substituir",
        "Insert Link" : "Inserir link",
        "Find" : "Localizar",
        "Replace" : "Substituir",
        "Replace all" : "Substituir tudo",
        "Match case" : "Diferenciar maiúsculas de minúsculas",
        "Whole word" : "Palavra inteira",
        "Reg Ex" : "Reg Ex",
        "Info" : "Informações",
        "Reached end of module." : "Atingiu o fim do módulo.",
        "Match Not Found" : "Correspondência não encontrada",
        "{0} matches replaced" : "{0} correspondências substituídas",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Genebra",
        "Georgia" : "Geórgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Nenhum",
        "Header 1" : "Cabeçalho 1",
        "Header 2" : "Cabeçalho 2",
        "Header 3" : "Cabeçalho 3",
        "Header 4" : "Cabeçalho 4",
        "Header 5" : "Cabeçalho 5",
        "Header 6" : "Cabeçalho 6",
        "Select" : "Selecionar",
        "Basic View" : "Exibição básica",
        "FullScreen" : "Tela inteira",
        "Expand" : "Expandir",
        "Collapse" : "Contrair",
        "List Type" : "Tipo de lista",
        "URL" : "URL",
        "Alt Text" : "Texto alternativo",
        "Open in new page" : "Abrir em nova página"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var zhCN = I18n.zhCN = {};

    zhCN.strings = {
        "Undo" : "撤消",
        "Redo" : "恢复",
        "Bold" : "粗体",
        "Italic" : "斜体",
        "Underline" : "下划线",
        "Super-script" : "上标",
        "Sub-script" : "下标",
        "Text Color" : "文本颜色",
        "Highlight Color" : "突出显示颜色",
        "Font Family" : "字体系列",
        "Font Size" : "字体大小",
        "Line Height" : "行高",
        "Letter Spacing" : "字母间距",
        "Paragraph Format" : "段落格式",
        "Justify Left" : "左对齐",
        "Justify Center" : "居中对齐",
        "Justify Full" : "全部两端对齐",
        "Justify Right" : "右对齐",
        "Margin Left" : "左边距",
        "Margin Right" : "右边距",
        "Margin Top" : "上边距",
        "Margin Bottom" : "下边距",
        "Bulleted List" : "项目符号列表",
        "Numbered List" : "编号列表",
        "Upper-case Alphabet List" : "大写字母列表",
        "Lower-case Alphabet List" : "小写字母列表",
        "Upper-case Roman List" : "大写罗马字母列表",
        "Lower-case Roman List" : "小写罗马字母列表",
        "Indent" : "缩进",
        "Outdent" : "升级",
        "Find & Replace" : "查找和替换",
        "Insert Link" : "插入链接",
        "Find" : "查找",
        "Replace" : "替换",
        "Replace all" : "全部替换",
        "Match case" : "区分大小写",
        "Whole word" : "全字",
        "Reg Ex" : "正则表达式",
        "Info" : "信息",
        "Reached end of module." : "已到模块末尾。",
        "Match Not Found" : "未找到匹配项",
        "{0} matches replaced" : "{0} 个匹配项已替换",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "无",
        "Header 1" : "标题 1",
        "Header 2" : "标题 2",
        "Header 3" : "标题 3",
        "Header 4" : "标题 4",
        "Header 5" : "标题 5",
        "Header 6" : "标题 6",
        "Select" : "选择",
        "Basic View" : "基本视图",
        "FullScreen" : "全屏",
        "Expand" : "展开",
        "Collapse" : "折叠",
        "List Type" : "列表类型",
        "URL" : "URL",
        "Alt Text" : "切换文本",
        "Open in new page" : "在新页面中打开"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var zhTW = I18n.zhTW = {};

    zhTW.strings = {
        "Undo" : "復原",
        "Redo" : "重做",
        "Bold" : "粗體",
        "Italic" : "斜體",
        "Underline" : "底線",
        "Super-script" : "上標",
        "Sub-script" : "下標",
        "Text Color" : "文字色彩",
        "Highlight Color" : "亮顯顏色",
        "Font Family" : "字型系列",
        "Font Size" : "字型大小",
        "Line Height" : "行高",
        "Letter Spacing" : "字母間隔",
        "Paragraph Format" : "段落格式",
        "Justify Left" : "向左對齊",
        "Justify Center" : "置中對齊",
        "Justify Full" : "左右對齊",
        "Justify Right" : "向右對齊",
        "Margin Left" : "左邊距",
        "Margin Right" : "右邊距",
        "Margin Top" : "上邊距",
        "Margin Bottom" : "下邊距",
        "Bulleted List" : "項目符號清單",
        "Numbered List" : "編號清單",
        "Upper-case Alphabet List" : "大寫字母清單",
        "Lower-case Alphabet List" : "小寫字母清單",
        "Upper-case Roman List" : "大寫 Roman 字清單",
        "Lower-case Roman List" : "小寫 Roman 清單",
        "Indent" : "縮排",
        "Outdent" : "凸排",
        "Find & Replace" : "尋找和取代",
        "Insert Link" : "插入連結",
        "Find" : "尋找",
        "Replace" : "替換",
        "Replace all" : "全部取代",
        "Match case" : "符合大小寫",
        "Whole word" : "全字",
        "Reg Ex" : "規則運算式",
        "Info" : "資訊",
        "Reached end of module." : "到達模組終點。",
        "Match Not Found" : "找不到相符的",
        "{0} matches replaced" : "取代{0}符合的項目",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "無",
        "Header 1" : "頁首 1",
        "Header 2" : "頁首 2",
        "Header 3" : "頁首 3",
        "Header 4" : "頁首 4",
        "Header 5" : "頁首 5",
        "Header 6" : "頁首 6",
        "Select" : "選取",
        "Basic View" : "基本檢視",
        "FullScreen" : "全螢幕",
        "Expand" : "展開",
        "Collapse" : "收縮",
        "List Type" : "列表類型",
        "URL" : "網址",
        "Alt Text" : "替代文字",
        "Open in new page" : "在新的頁面中開啟"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/28/2016.
 */

window.Form = window.Form || {};

Form.rte = Form.rte || {};

Form.rte.util = Form.rte.util || {};

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 8/1/2016.
 */
(function (ns) {

    var RTEUtils = ns.RTEUtils = {};

    RTEUtils.isIE = function () {
        var ua = window.navigator.userAgent;
        var msie = ua.indexOf('MSIE ');
        if (msie > 0) {
            // IE 10 or older => return version number
            return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
        }
        var trident = ua.indexOf('Trident/');
        if (trident > 0) {
            // IE 11 => return version number
            var rv = ua.indexOf('rv:');
            return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
        }
        var edge = ua.indexOf('Edge/');
        if (edge > 0) {
            // IE 12 => return version number
            return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
        }
        // other browser
        return false;
    };
    RTEUtils.addSpectrumGradient = function (selector, colorValue) {
        if (selector) {
            $(selector).css({"background-image" : "-webkit-gradient(linear, left top, right top, color-stop(0, #fff), color-stop(.5, #" + colorValue + "), color-stop(1, #000))"});
            $(selector).css({"background-image" : "-moz-linear-gradient(left center, #fff 0, #" + colorValue + " 50%, #000 100%)"});
            $(selector).css({"background-image" : "-webkit-linear-gradient(left, #fff 0, #" + colorValue + " 50%, #000 100%)"});
            $(selector).css({"background-image" : "-o-linear-gradient(left, #fff 0, #" + colorValue + " 50%, #000 100%)"});
            $(selector).css({"background-image" : "linear-gradient(to right, #fff 0, #" + colorValue + " 50%, #000 100%)"});
            $(selector).css({"background-repeat" : "repeat-x"});
        }
    };

})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var StringHelper = ns.StringHelper = {};

    /**
     * Removes any leading and trailing slashes, either '/' or '\', on the specified string.
     * @param value The string from which slashes are to be trimmed.
     * @return The original string less any trailing slashes.
     */
    StringHelper.trimSlashes = function (value) {

        if (!value) {// if null or empty
            return value;
        }

        var len = value.length;

        // remove leading slashes
        var start = 0; // must be index of first character to include
        var c = value.charAt(start);
        while (c == '/' || c == '\\') {
            start++;
            if (start >= len) {
                start = len;
                break;
            }
            c = value.charAt(start);
        }
        if (start >= len) {// all slashes
            return "";
        }

        // at this point, there's at least one character we want to retain

        // remove trailing slashes
        var end = len; // must be 1 more than the last character we want to include
        c = value.charAt(end - 1);
        while (c == '/' || c == '\\') {
            end--;
            if (end < 0) {
                end = 0;
                break;
            }

            c = value.charAt(end - 1);
        }
        return value.substring(start, end);
    };
    StringHelper.repeat = function (c, count) {
        var s = "";
        if (c == null) {
            return s;
        }

        for (var i = 0; i < count; i++) {
            s += c;
        }
        return s;
    };
    /**
     * Determines if the specified string has the specified postfix.
     * @param str The string to be verified.
     * @param postFix The postfix to search for.
     * @return True if str has the postfix specified; true if postfix is null/empty since any non-null string can have an empty postfix;
     *  false if str is null or does not have the specified postfix.
     */
    StringHelper.hasPostFix = function (str, postFix) {
        if (str == null) {
            return false;
        }

        if (!postFix) {
            return true;
        } // any string has an empty postfix!
        return (str.indexOf(postFix) == (str.length - postFix.length));
    };

    /**
     * Tests the string to see if it only contains whitespace characters. This is slightly different from
     *  <code>StringUtil.isWhitespace()</code> in that it tests all characters, not just one.
     * @param str The string to test.
     * @return True if the str is made-up entirely of whitespace; false if not. Null strings will result in true.
     */
    StringHelper.isWhitespace = function (str) {
        if (str == null) {
            return true;
        }
        return str.match(/[^\s]+/g) == null; // matches at least one non-whitespace character so if there's no match, it's entirely whitespace
    };

    /**
     * Stretches the specified string to the specified length using the specified pad character.
     * @param str The string to stretch.
     * @param pad The (single) character to use when stretching.
     * @param length The length to stretch to.
     * @param prefix True if the pad should be added to the left (before the contents of the string); false if it should be appended
     *  to the end of the contents of the string.
     * @return The stretched string. If <code>str</code> is null or empty, it simply becomes a string of <code>pad</code> characters
     *  of the specified <code>length</code>.
     * @throws Error Pad must be a single character.
     */
    StringHelper.stretch = function (str, pad, length, prefix) {
        if (!pad || length <= 0) {
            return str;
        }

        if (pad.length != 1) {
            throw new Error("pad must be a single character: " + pad);
        } // assert
        var i = 0;
        if (str == null) {
            str = "";
            for (; i < length; i++) {
                str += pad;
            }
            return str;
        }
        if (str.length >= length) {
            return str;
        }
        var count = length - str.length;
        for (; i < count; i++) {
            if (prefix) {
                str = pad + str;
            } else {
                str = str + pad;
            }
        }
        return str;
    };

    /**
     * Replaces the all the occurance of target string with replacement string for a given input string
     * @param inputString The Input String
     * @param target
     * @param replacement
     * @return
     *
     */
    StringHelper.replaceAll = function (inputString, target, replacement) {
        if (inputString == null || target == null) {
            return inputString;
        }
        var escapedTarget = StringHelper.escapeRegexChars(target);
        var pattern = new RegExp(escapedTarget, "g");
        var newString = inputString.replace(pattern, replacement);
        return newString;
    };

    StringHelper.escapeRegexChars = function (s) {
        var newString = s.replace(new RegExp("([{}\(\)\^$&.\*\?\/\+\|\[\\\\]|\]|\-)", "g"), "\\$1");
        return newString;
    };

    StringHelper.restrict = function (str, restrict) {
        // A null 'restrict' string means all characters are allowed.
        if (restrict == null) {
            return str;
        }

        // An empty 'restrict' string means no characters are allowed.
        if (restrict == "") {
            return "";
        }
        // Otherwise, we need to test each character in 'str'
        // to determine whether the 'restrict' string allows it.
        var charCodes = [];

        var n = str.length;
        for (var i = 0; i < n; i++) {
            var charCode = str.charCodeAt(i);
            if (StringHelper.testCharacter(charCode, restrict)) {
                charCodes.push(charCode);
            }
        }
        return String.fromCharCode.apply(null, charCodes);
    };

    StringHelper.testCharacter = function (charCode, restrict) {
        var allowIt = false;
        var inBackSlash = false;
        var inRange = false;
        var setFlag = true;
        var lastCode = 0;
        var n = restrict.length;
        var code;

        if (n > 0) {
            code = restrict.charCodeAt(0);
            if (code == 94) {// caret
                allowIt = true;
            }
        }
        for (var i = 0; i < n; i++) {
            code = restrict.charCodeAt(i);
            var acceptCode = false;
            if (!inBackSlash) {
                if (code == 45) {// hyphen
                    inRange = true;
                } else if (code == 94) {// caret
                    setFlag = !setFlag;
                } else if (code == 92) {// backslash
                    inBackSlash = true;
                } else {
                    acceptCode = true;
                }
            } else {
                acceptCode = true;
                inBackSlash = false;
            }
            if (acceptCode) {
                if (inRange) {
                    if (lastCode <= charCode && charCode <= code) {
                        allowIt = setFlag;
                    }
                    inRange = false;
                    lastCode = 0;
                } else {
                    if (charCode == code) {
                        allowIt = setFlag;
                    }
                    lastCode = code;
                }
            }
        }
        return allowIt;
    };

    StringHelper.endsWith = function (str, suffix) {
        if (str && suffix && str.indexOf(suffix, str.length - suffix.length) !== -1) {
            return true;
        } else {
            return false;
        }
    };

    StringHelper.startsWith = function (str, prefix) {
        if (str && prefix && str.indexOf(prefix) === 0) {
            return true;
        } else {
            return false;
        }
    };

})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

var XfaElem, XfaXhtml, XfaSchema, XfaAtt, XfaVal;

var XfaData;

var XfaMimeType;

var XfaDataElem;

XfaDataElem = Form.rte.util.XfaDataElem = {};
XfaDataElem.DATASETS = "datasets";
XfaDataElem.DATA = "data";
XfaDataElem._elemTagMap = null;
XfaDataElem.isElement = function (elemTag) {
    // create on first use
    if (!XfaDataElem._elemTagMap) {

        XfaDataElem._elemTagMap = {};
        var element, staticConstList = Object.keys(XfaDataElem);

        for (var index = 0; index < staticConstList.length; index++) {
            element = staticConstList[index];
            // element members are expected not to have any underscores in their names
            if (element.indexOf("_") < 0 && typeof XfaDataElem[element] == "string") {
                XfaDataElem._elemTagMap[XfaDataElem[element]] = true;
            }
        }
    }
    return (elemTag in XfaDataElem._elemTagMap);
};

XfaData = Form.rte.util.XfaData = {};
XfaData.XFADATANSURI = "http://www.xfa.org/schema/xfa-data/1.0/";

XfaMimeType = Form.rte.util.XfaMimeType = {};
XfaMimeType.JPEG = "image/jpg";
/** MIME type for TIFF images. */
XfaMimeType.TIFF = "image/tif";
/** MIME type for GIF images. */
XfaMimeType.GIF = "image/gif";
/** MIME type for bitmap images. */
XfaMimeType.BMP = "image/bmp";
/** MIME type for PNG images (only indexed PNGs with one transparent color are supported in XFA forms). */
XfaMimeType.PNG = "image/png";
/** MIME type for plain text. */
XfaMimeType.PLAINTEXT = "text/plain";
/** MIME type for rich text. */
XfaMimeType.RICHTEXT = "text/html";
/** MIME type for xml text. */
XfaMimeType.XMLTEXT = "text/xml";

XfaXhtml = Form.rte.util.XfaXhtml = {};
XfaXhtml.XHTMLNSURI = "http://www.w3.org/1999/xhtml";
/** AXTE API Version used in XFA XHTML &lt;body&gt; tag (currently set to that which is used with LiveCycle ES Update 1 (Designer 8.2)). */
XfaXhtml.AXTEAPIVERSION = "2.7.0.0";

/** The root node of XFA rich text (XHTML) as set in rich text draws and fields. The entire rich text value is contained within a &lt;body&gt; element. */
XfaXhtml.BODY = "body";

/** Spacerun style name. */
XfaXhtml.SPACERUNSTYLENAME = "xfa-spacerun";
/** Spacerun style value. */
XfaXhtml.SPACERUNSTYLEVALUE = "yes";
/** Spacerun style (name:value). */
XfaXhtml.SPACERUNSTYLE = XfaXhtml.SPACERUNSTYLENAME + ':' + XfaXhtml.SPACERUNSTYLEVALUE;
/** Spacerun opening tag. */
XfaXhtml.SPACERUNOPEN = '<span style="' + XfaXhtml.SPACERUNSTYLE + '">';
/** Spacerun closing tag. */
XfaXhtml.SPACERUNCLOSE = '</span>';
XfaElem = Form.rte.util.XfaElem = {};
XfaElem.APPEARANCEFILTER = "appearanceFilter";
XfaElem.ARC = "arc";
XfaElem.AREA = "area";
XfaElem.BARCODE = "barcode";
XfaElem.BIND = "bind";
XfaElem.BOOLEAN = "boolean";
XfaElem.BORDER = "border";
XfaElem.BUTTON = "button";
XfaElem.CAPTION = "caption";
XfaElem.CERTIFICATE = "certificate";
XfaElem.CHECKBUTTON = "checkButton";
XfaElem.CHOICELIST = "choiceList";
XfaElem.COLOR = "color";
XfaElem.CONTENTAREA = "contentArea";
XfaElem.DATE = "date";
XfaElem.DATETIME = "dateTime";
XfaElem.DATETIMEEDIT = "dateTimeEdit";
XfaElem.DECIMAL = "decimal";
XfaElem.DEFAULTUI = "defaultUi";
XfaElem.DIGESTMETHOD = "digestMethod";
XfaElem.DRAW = "draw";
XfaElem.EDGE = "edge";
XfaElem.ENCODING = "encoding";
XfaElem.EXCLGROUP = "exclGroup";
XfaElem.EXDATA = "exData";
XfaElem.EXOBJECT = "exObject";
XfaElem.EVENT = "event";
XfaElem.EXECUTE = "execute";
XfaElem.FIELD = "field";
XfaElem.FILL = "fill";
XfaElem.FLOAT = "float";
XfaElem.FONT = "font";
XfaElem.HANDLER = "handler";
XfaElem.IMAGE = "image";
XfaElem.IMAGEEDIT = "imageEdit";
XfaElem.INTEGER = "integer";
XfaElem.ITEMS = "items";
XfaElem.KEEP = "keep";
XfaElem.LINE = "line";
XfaElem.LINEAR = "linear";
XfaElem.LOCKDOCUMENT = "lockDocument";
XfaElem.MARGIN = "margin";
XfaElem.MEDIUM = "medium";
XfaElem.NUMERICEDIT = "numericEdit";
XfaElem.OID = "oid";
XfaElem.PAGEAREA = "pageArea";
XfaElem.PAGESET = "pageSet";
XfaElem.PARA = "para";
XfaElem.PASSWORDEDIT = "passwordEdit";
XfaElem.PATTERN = "pattern";
XfaElem.PICTURE = "picture";
XfaElem.RADIAL = "radial";
XfaElem.RECTANGLE = "rectangle";
XfaElem.REASON = "reason";
XfaElem.REF = "ref";
XfaElem.SCRIPT = "script";
XfaElem.SIGNATURE = "signature";
XfaElem.SIGNDATA = "signData";
XfaElem.SOLID = "solid";
XfaElem.SPEAK = "speak";
XfaElem.STIPPLE = "stipple";
XfaElem.SUBFORM = "subform";
XfaElem.SUBFORMSET = "subformSet";
XfaElem.SUBJECTDN = "subjectDN";
XfaElem.SUBMIT = "submit";
XfaElem.TEMPLATE = "template";
XfaElem.TEXT = "text";
XfaElem.TEXTEDIT = "textEdit";
XfaElem.TIME = "time";
XfaElem.TOOLTIP = "toolTip";
XfaElem.UI = "ui";
XfaElem.VALUE = "value";
XfaElem.VARIABLES = "variables";
XfaElem._elemTagMap = null;

/**
 * Determines if the specified element name is a valid XFA Template element name.
 * @param elemTag The name to test.
 * @return True if it's an XFA Template element name; false if not.
 */
XfaElem.isElement = function (elemTag) {
    // create on first use
    if (!XfaElem._elemTagMap) {
        XfaElem._elemTagMap = {};
        var element, staticConstList = Object.keys(XfaElem);
        for (var index = 0; index < staticConstList.length; index++) {
            element = staticConstList[index];
            // element members are expected not to have any underscores in their names
            if (element.indexOf("_") < 0 && typeof XfaElem[element] == "string") {
                XfaElem._elemTagMap[XfaElem[element]] = true;
            }
        }
    }
    return (elemTag in XfaElem._elemTagMap);
};

XfaAtt = Form.rte.util.XfaAtt = {};

XfaAtt.ACTIVITY = "activity";
XfaAtt.ASPECT = "aspect";
XfaAtt.ALLOWRICHTEXT = "allowRichText";
XfaAtt.BOTTOMINSET = "bottomInset";
XfaAtt.COMMITON = "commitOn";
XfaAtt.CONTENTTYPE = "contentType";
XfaAtt.H = "h";
XfaAtt.HREF = "href";
XfaAtt.ID = "id";
XfaAtt.INTACT = "intact";
XfaAtt.LAYOUT = "layout";
XfaAtt.LEFTINSET = "leftInset";
XfaAtt.LONG = "long";
XfaAtt.MARGINLEFT = "marginLeft";
XfaAtt.MARGINRIGHT = "marginRight";
XfaAtt.MATCH = "match";
XfaAtt.MAXCHARS = "maxChars";
XfaAtt.MAXH = "maxH";
XfaAtt.MAXLENGTH = "maxLength";
XfaAtt.MAXW = "maxW";
XfaAtt.MINH = "minH";
XfaAtt.MINW = "minW";
XfaAtt.MULTILINE = "multiLine";
XfaAtt.NAME = "name";
XfaAtt.OPEN = "open";
XfaAtt.ORIENTATION = "orientation";
XfaAtt.PAGEPOSITION = "pagePosition";
XfaAtt.PLACEMENT = "placement";
XfaAtt.PRESENCE = "presence";
XfaAtt.REF = "ref";
XfaAtt.RELATION = "relation";
XfaAtt.RESERVE = "reserve";
XfaAtt.RIGHTINSET = "rightInset";
XfaAtt.RUNAT = "runAt";
XfaAtt.SAVE = "save";
XfaAtt.SHORT = "short";
XfaAtt.SIZE = "size";
XfaAtt.SPACEABOVE = "spaceAbove";
XfaAtt.SPACEBELOW = "spaceBelow";
XfaAtt.STOCK = "stock";
XfaAtt.STROKE = "stroke";
XfaAtt.TEXTENTRY = "textEntry";
XfaAtt.TOPINSET = "topInset";
XfaAtt.TYPEFACE = "typeface";
XfaAtt.USE = "use";
XfaAtt.USEHREF = "usehref";
XfaAtt.VALIGN = "vAlign";
XfaAtt.VALUE = "value";
XfaAtt.WEIGHT = "weight";
XfaAtt.W = "w";
XfaAtt.X = "x";
XfaAtt.Y = "y";
/** Map of attribute names (string values of static attribute constant members of XfaAtt) to an as-yet unused value. */
XfaAtt._attTagMap = null;
XfaAtt.isAttribute = function (attTag) {
    // create on first use
    if (!XfaAtt._attTagMap) {
        XfaAtt._attTagMap = {};
        var element, staticConstList = Object.keys(XfaAtt);
        for (var index = 0; index < staticConstList.length; index++) {
            element = staticConstList[index];
            // element members are expected not to have any underscores in their names
            if (element.indexOf("_") < 0 && typeof XfaAtt[element] == "string") {
                this._attTagMap[XfaAtt[element]] = true;
            }
        }
    }
    return (attTag in this._attTagMap);
};

XfaVal = Form.rte.util.XfaVal = {};

XfaVal.ACTUAL = "actual";
XfaVal.ALWAYS = "always";
XfaVal.ANY = "any";
XfaVal.APPXFORMCALC = "application/x-formcalc";
XfaVal.APPXJAVASCRIPT = "application/x-javascript";
XfaVal.BOLD = "bold";
XfaVal.BOTH = "both";
XfaVal.BOTTOM = "bottom";
XfaVal.CHANGE = "change";
XfaVal.CLICK = "click";
XfaVal.CLIENT = "client";
XfaVal.CONTENTAREA = "contentArea";
XfaVal.DASHDOT = "dashDot";
XfaVal.DASHDOTDOT = "dashDotDot";
XfaVal.DASHED = "dashed";
XfaVal.DATAREF = "dataRef";
XfaVal.DOCCLOSE = "docClose";
XfaVal.DOCREADY = "docReady";
XfaVal.DOTTED = "dotted";
XfaVal.EMBOSSED = "embossed";
XfaVal.ENTER = "enter";
XfaVal.ETCHED = "etched";
XfaVal.EXIT = "exit";
XfaVal.FIRST = "first";
XfaVal.FIT = "fit";
XfaVal.FULL = "full";
XfaVal.GLOBAL = "global";
XfaVal.HEIGHT = "height";
XfaVal.HIDDEN = "hidden";
XfaVal.INDEXCHANGE = "indexChange";
XfaVal.INITIALIZE = "initialize";
XfaVal.INLINE = "inline";
XfaVal.INVISIBLE = "invisible";
XfaVal.LANDSCAPE = "landscape";
XfaVal.LAST = "last";
XfaVal.LEFT = "left";
XfaVal.LETTER = "letter";
XfaVal.LOWERED = "lowered";
XfaVal.LRTB = "lr-tb";
XfaVal.MIDDLE = "middle";
XfaVal.MOUSEDOWN = "mouseDown";
XfaVal.MOUSEENTER = "mouseEnter";
XfaVal.MOUSEEXIT = "mouseExit";
XfaVal.MOUSEUP = "mouseUp";
XfaVal.MULTISELECT = "multiSelect";
XfaVal.NONE = "none";
XfaVal.NORMAL = "normal";
XfaVal.ONCE = "once";
XfaVal.ONENTRY = "onEntry";
XfaVal.ONLY = "only";
XfaVal.ORDEREDOCCURRENCE = "orderedOccurrence";
XfaVal.PAGEAREA = "pageArea";
XfaVal.PORTRAIT = "portrait";
XfaVal.POSITION = "position";
XfaVal.POSTEXECUTE = "postExecute";
XfaVal.POSTOPEN = "postOpen";
XfaVal.POSTPRINT = "postPrint";
XfaVal.POSTSAVE = "postSave";
XfaVal.POSTSIGN = "postSign";
XfaVal.POSTSUBMIT = "postSubmit";
XfaVal.PREEXECUTE = "preExecute";
XfaVal.PREOPEN = "preOpen";
XfaVal.PREPRINT = "prePrint";
XfaVal.PRESAVE = "preSave";
XfaVal.PRESIGN = "preSign";
XfaVal.PRESUBMIT = "preSubmit";
XfaVal.RAISED = "raised";
XfaVal.READY = "ready";
XfaVal.REST = "rest";
XfaVal.RIGHT = "right";
XfaVal.RLTB = "rl-tb";
XfaVal.ROW = "row";
XfaVal.SELECT = "select";
XfaVal.SERVER = "server";
XfaVal.SOLID = "solid";
XfaVal.TABLE = "table";
XfaVal.TB = "tb";
XfaVal.TOP = "top";
XfaVal.USERCONTROL = "userControl";
XfaVal.VISIBLE = "visible";
XfaVal.WIDTH = "width";

XfaSchema = Form.rte.util.XfaSchema = {};
/** XFA namespace prefix. */
XfaSchema.XFANS = "xfa";

/** XFA 2.8 namespace URI. */
XfaSchema.XFAVERSION28 = "http://www.xfa.org/schema/xfa-template/2.8/";
/** XFA version for all new templates. */
XfaSchema.TEMPLATEVERSION = XfaSchema.XFAVERSION28;

/** Default for schema values that are the number zero. */
XfaSchema.ZERO = "0";
/** Default for schema values that are the number one. */
XfaSchema.ONE = "1";
/** Default for schema values that are the number minus one. */
XfaSchema.MINUSONE = "-1";
/** Point units. */
XfaSchema.UNITPOINT = "pt";
/** Millimeter units. */
XfaSchema.UNITMILLI = "mm";
/** Centimeter units. */
XfaSchema.UNITCENTI = "cm";
/** Inch units. */
XfaSchema.UNITINCH = "in";
/** Default units for schema values that are measurements. */
XfaSchema.DEFAULTUNITS = XfaSchema.UNITINCH;
/** Default output units whem editing measurement values. Millimeters are more precise. */
XfaSchema.WRITEUNITS = XfaSchema.UNITMILLI;
/** Default for schema values that are "cdata". */
XfaSchema.CDATA = "";
/** Default for schema values that are "xml-id". */
XfaSchema.XMLID = "";
/** Default font for typeface properties. Actual default is "Courier Std" however "Myriad Pro" is the Adobe standard font. */
XfaSchema.DEFAULTFONT = "Myriad Pro";
/** Black color. */
XfaSchema.BLACK = "0,0,0";

// TODO: Consider moving XfaSchema.XFAFORMDOM into new XfaScripting or scrip.XfaFormDom or something along those lines.
/* XFA Form DOM scripting prefix. */
//XfaSchema.XFAFORMDOM = "xfa.form";

// TODO: Workaround for https://bugs.adobe.com/jira/browse/ASC-2231 (not technically part of the XFA Schema but
//  somehow using the const from XfaSchema rather than XfaFragUtils works better when setting it as the
//  default value for a function parameter).
/** Default name for a new fragment. */
XfaSchema.DEFAULTFRAGNAME = "Fragment1";
/** Default name for a new form object (field, draw, subform, etc.). */
XfaSchema.DEFAULTOBJNAME = "FormObject";
/** Default name for a root subform. */
XfaSchema.DEFAULTROOTNAME = "form1";

/** Default processing instruction domain for PIs generated and read by LC Designer. */
XfaSchema.PIDESDOMAIN = "templateDesigner";

/** Processing instruction that identifies a form object as a fragment. This PI object also defines a "value" property that holds the PI's expected (and only) value. */
XfaSchema.PIFRAGISFRAG = {domain : XfaSchema.PIDESDOMAIN, key : "isFragment", value : "yes"};
/** Processing instruction that contains the title metadata for a fragment. */
XfaSchema.PIFRAGTITLE = {domain : XfaSchema.PIDESDOMAIN, key : "fragmentTitle"};
/** Processing instruction that contains the description metadata for a fragment. */
XfaSchema.PIFRAGDESC = {domain : XfaSchema.PIDESDOMAIN, key : "fragmentDescription"};

/**
 * Returns true if the specified XFA element tag is a container node (may contain other containers or fields/draws). Protos are excluded.
 * @param elemTag The XFA element tag to check as being a container.
 * @param includeExGrp If true, the &lt;exclGroup&gt; node is considered a container. Otherwise, it is not. Note that in terms of
 *  "content", exclusion group nodes may only contain &lt;field&gt; nodes which is more restrictive than other container types.
 */
XfaSchema.isContainerElem = function (elemTag, includeExGrp) {
    includeExGrp = includeExGrp !== undefined ? includeExGrp : true;

    switch (elemTag) {
        case XfaElem.SUBFORM:
        case XfaElem.SUBFORMSET:
        case XfaElem.AREA:
        case XfaElem.PAGEAREA:
            return true;
            break;

        case XfaElem.EXCLGROUP:
            return includeExGrp;
            break;

        default:
            break;
    }

    return false;
};

/** Returns true if the specified XFA element tag defines form content (could be a field, draw or some type of container node). Protos are excluded. */
XfaSchema.isContentElem = function (elemTag) {
    switch (elemTag) {
        case XfaElem.DRAW:
        case XfaElem.FIELD:
            return true;
            break;
        default:
            break;
    }
    return XfaSchema.isContainerElem(elemTag);
};

/**
 * Returns the default value for a given attribute tag. If the attribute is invalid or unknown, null is returned. If there isn't enough context to determine
 *  the default, null is returned (e.g. the node may be orphaned and a particular parent type is required, like the default for the "allowRichText" can't be
 *  determined if the <code>textEdit</code> node is orphaned because a <code>field</code> or <code>draw</code> parent containing a <code>value</code> is required).
 * @param attTag The attribute name for which to retrieve the default.
 * @param contextNode XFA node that provides necessary context for the default value. For example, the "allowRichText" attribute has different default values
 *  depending on whether the text field/draw has &lt;exData&gt; as its value type or not. This is expected to be the node on which the attribute would be set (i.e.
 *  when attTag is "allowRichText", contextNode is expected to be a &lt;textEdit&gt; node).
 * @return The default value for the attribute or null if the attribute is unknown. Will also return null if contextNode is specified but could not be used
 *  to determine the appropriate default value for the specified attribute.
 * @throws com.adobe.xfa.xfautil.Error Attribute default cannot be correctly determined without both the attribute tag and the context node.
 */
XfaSchema.attDefault = function (attTag, contextNode) {
    if (!attTag || !contextNode) {
        throw new Error("Attribute default cannot be correctly determined without both the attribute tag and the context node.");
        return null;
    }

    // TODO: SCHEMA VALIDATION: Eventually, we'll need to validate that the attribute sought is valid on the given context node.
    var def = null;
    switch (attTag) {
        // NOTE: An auto-generated (from XTG's main code base) XFA spec should be available here for reference:
        // http://xtgwin1.can.adobe.com/main_build/xtg/docs/schema/template-syntax.html

        //////////////////////////////////
        // in alphabetical order
        //////////////////////////////////
        case XfaAtt.ACTIVITY:
            def = XfaVal.CLICK;
            break;
        case XfaAtt.ASPECT:
            def = XfaVal.FIT;
            break;
        case XfaAtt.ALLOWRICHTEXT:
            def = XfaSchema._getAllowRichTextDefault(contextNode);
            break;
        case XfaAtt.BOTTOMINSET:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.COMMITON:
            def = XfaVal.SELECT;
            break;
        case XfaAtt.CONTENTTYPE:
            def = XfaSchema._getContentTypeDefault(contextNode);
            break;
        case XfaAtt.H:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.HREF:
            def = XfaSchema.CDATA;
            break;
        case XfaAtt.ID:
            def = XfaSchema.XMLID;
            break;
        case XfaAtt.INTACT:
            def = XfaSchema._getIntactDefault(contextNode);
            break;
        case XfaAtt.LAYOUT:
            def = XfaVal.POSITION;
            break;
        case XfaAtt.LEFTINSET:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.LONG:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MARGINLEFT:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MARGINRIGHT:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MATCH:
            def = XfaVal.ONCE;
            break;
        case XfaAtt.MAXCHARS:
            def = XfaSchema.ZERO;
            break;
        case XfaAtt.MAXH:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MAXLENGTH:
            def = XfaSchema.MINUSONE;
            break;
        case XfaAtt.MAXW:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MINH:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MINW:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MULTILINE:
            def = XfaSchema._getMultiLineDefault(contextNode);
            break;
        case XfaAtt.NAME:
            def = XfaSchema.XMLID;
            break;
        case XfaAtt.OPEN:
            def = XfaVal.USERCONTROL;
            break;
        case XfaAtt.ORIENTATION:
            def = XfaVal.PORTRAIT;
            break;
        case XfaAtt.PAGEPOSITION:
            def = XfaVal.ANY;
            break;
        case XfaAtt.PLACEMENT:
            def = XfaVal.LEFT;
            break;
        case XfaAtt.PRESENCE:
            def = XfaVal.VISIBLE;
            break;
        case XfaAtt.REF:
            def = XfaSchema.CDATA;
            break;
        case XfaAtt.RELATION:
            def = XfaVal.ORDEREDOCCURRENCE;
            break;
        case XfaAtt.RESERVE:
            def = XfaSchema.MINUSONE;
            break;
        case XfaAtt.RIGHTINSET:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.RUNAT:
            def = XfaVal.CLIENT;
            break;
        case XfaAtt.SAVE:
            def = XfaSchema.ZERO;
            break;
        case XfaAtt.SHORT:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.SIZE:
            def = "10" + XfaSchema.UNITPOINT;
            break;
        case XfaAtt.SPACEABOVE:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.SPACEBELOW:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.STOCK:
            def = XfaVal.LETTER;
            break;
        case XfaAtt.STROKE:
            def = XfaVal.SOLID;
            break;
        case XfaAtt.TEXTENTRY:
            def = XfaSchema.ZERO;
            break;
        case XfaAtt.TOPINSET:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.TYPEFACE:
            def = XfaSchema.DEFAULTFONT;
            break;
        case XfaAtt.USE:
            def = XfaSchema.CDATA;
            break;
        case XfaAtt.USEHREF:
            def = XfaSchema.CDATA;
            break;
        case XfaAtt.VALIGN:
            def = XfaVal.TOP;
            break;
        case XfaAtt.VALUE:
            def = XfaSchema.BLACK;
            break;
        case XfaAtt.WEIGHT:
            def = XfaVal.NORMAL;
            break;
        case XfaAtt.W:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.X:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.Y:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;

        default:
            Window.console.error("no default attribute value for '" + attTag + "' tag");
            break;
    }
    return def;
};

/**
 * Returns the default child element class name given a tag that contains a one-of element property.
 * <p>For example, the <code>//field/ui</code> element contains a one-of property which specifies the field's UI type for which the default is <code>textField</code>.
 *  Therefore, calling <code>oneOfDefault(&lt;field&gt;&lt;ui/&gt;&lt;/field&gt;)</code> would return XfaElem.TEXTFIELD.</p>
 * @param contextNode The node whose one-of property default is sought.
 * @return An XFA element name, from XfaElem, which identifies the class name of the default one-of property of the context node. Returns null if no default is defined.
 *  To determine if the an element has a one-of property, you should use XfaSchema.hasOneOfProp().
 * @see com.adobe.xfa.XfaElem
 * @see #hasOneOfProp()
 * @throws com.adobe.xfa.xfautil.Error One-of default cannot be correctly determined without the context node.
 */
XfaSchema.oneOfDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("One-of default cannot be correctly determined without the context node.");
        return null;
    }
    var def = null;
    switch (contextNode.className) {
        // NOTE: An auto-generated (from XTG's main code base) XFA spec should be available here for reference:
        // http://xtgwin1.can.adobe.com/main_build/xtg/docs/schema/template-syntax.html

        //////////////////////////////////
        // in alphabetical order
        //////////////////////////////////
        case XfaElem.EVENT:
            def = XfaElem.SCRIPT;
            break; // no actual default -- our default, as the "XFA application" is <script> (matches XTG default)
        case XfaElem.FILL:
            def = XfaElem.SOLID;
            break; // no actual default -- our default, as the "XFA application" is <solid> (matches XTG default)
        case XfaElem.UI:
            def = XfaElem.TEXTEDIT;
            break; // no actual default -- our default, as the "XFA application" is <textEdit> (matches XTG default)
        case XfaElem.VALUE:
            def = XfaElem.TEXT;
            break; // no actual default -- our default, as the "XFA application" is <text> (matches XTG default)

        default:
            window.console.error("no default one-of element property for '" + contextNode.className + "' tag");
            break;
    }
    return def;
};

/**
 * Determines if the specified XFA element has a one-of property.
 * @param elemTag The XFA element to check for a one-of property.
 * @return True if the XFA element has a one-of property; false if not.
 */
XfaSchema.hasOneOfProp = function (elemTag) {
    var hasOneOf = false;

    switch (elemTag) {
        // NOTE: An auto-generated (from XTG's main code base) XFA spec should be available here for reference:
        // http://xtgwin1.can.adobe.com/main_build/xtg/docs/schema/template-syntax.html

        //////////////////////////////////
        // in alphabetical order
        //////////////////////////////////
        case XfaElem.EVENT:
        case XfaElem.FILL:
        case XfaElem.UI:
        case XfaElem.VALUE:
            hasOneOf = true;
            break;
    }
    return hasOneOf;
};

/**
 * Determines if the specified XFA element class name is a one-of property of the specified context node.
 * <p>For example, calling <code>isOneOfProp(XfaElem.TEXTEDIT, &lt;field&gt;&lt;ui/&gt;&lt;/field&gt;)</code> would return true.</p>
 * @param elemTag The XFA element class name, from XfaElem, which is the tag to test as a one-of property of the context node.
 * @param contextNode The XFA node that provides context to the test since some elements may be one-of properties of some other elements while
 *  they may not be of others. For example, the &lt;text&gt; element is a one-of property of &lt;value&gt; but a 1/n property of &lt;variables&gt;.
 * @throws com.adobe.xfa.xfautil.Error One-of property cannot be correctly identified without the element tag and the context node.
 */
XfaSchema.isOneOfProp = function (elemTag, contextNode) {
    if (!elemTag || !contextNode) {
        throw new Error("One-of property cannot be correctly identified without the element tag and the context node.");
        return false;
    }

    var isOneOf = false;

    switch (contextNode.className) {
        // NOTE: An auto-generated (from XTG's main code base) XFA spec should be available here for reference:
        // http://xtgwin1.can.adobe.com/main_build/xtg/docs/schema/template-syntax.html

        //////////////////////////////////
        // in alphabetical order
        //////////////////////////////////
        case XfaElem.EVENT: {
            switch (elemTag) {
                case XfaElem.EXECUTE:
                case XfaElem.SCRIPT:
                case XfaElem.SIGNDATA:
                case XfaElem.SUBMIT:
                    isOneOf = true;
                    break;
            }
            break;
        }

        case XfaElem.FILL: {
            switch (elemTag) {
                case XfaElem.LINEAR:
                case XfaElem.PATTERN:
                case XfaElem.RADIAL:
                case XfaElem.SOLID:
                case XfaElem.STIPPLE:
                    isOneOf = true;
                    break;
            }
            break;
        }

        case XfaElem.UI: {
            switch (elemTag) {
                case XfaElem.BARCODE:
                case XfaElem.BUTTON:
                case XfaElem.CHECKBUTTON:
                case XfaElem.CHOICELIST:
                case XfaElem.DATETIMEEDIT:
                case XfaElem.DEFAULTUI:
                case XfaElem.EXOBJECT:
                case XfaElem.IMAGEEDIT:
                case XfaElem.NUMERICEDIT:
                case XfaElem.PASSWORDEDIT:
                case XfaElem.SIGNATURE:
                case XfaElem.TEXTEDIT:
                    isOneOf = true;
                    break;
            }
            break;
        }

        case XfaElem.VALUE: {
            switch (elemTag) {
                case XfaElem.ARC:
                case XfaElem.BOOLEAN:
                case XfaElem.DATE:
                case XfaElem.DATETIME:
                case XfaElem.DECIMAL:
                case XfaElem.EXDATA:
                case XfaElem.FLOAT:
                case XfaElem.IMAGE:
                case XfaElem.LINE:
                case XfaElem.RECTANGLE:
                case XfaElem.TEXT:
                case XfaElem.TIME:
                    isOneOf = true;
                    break;
            }
            break;
        }
    }
    return isOneOf;
};

/**
 * Determines if the specified XFA element contains CDATA or PCDATA content. If it does, it means the node does not contain any XFA elements.
 * @param elemTag The XFA element to check for CDATA content.
 * @return True if the XFA element has CDATA content; false if not.
 */
XfaSchema.containsCData = function (elemTag) {
    var hasCData = false;
    switch (elemTag) {
        case XfaElem.APPEARANCEFILTER:
        case XfaElem.BOOLEAN:
        case XfaElem.CERTIFICATE:
        case XfaElem.DATE:
        case XfaElem.DATETIME:
        case XfaElem.DECIMAL:
        case XfaElem.DIGESTMETHOD:
        case XfaElem.ENCODING:
        case XfaElem.EXDATA:
        case XfaElem.FLOAT:
        case XfaElem.HANDLER:
        case XfaElem.IMAGE:
        case XfaElem.INTEGER:
        case XfaElem.LOCKDOCUMENT:
        case XfaElem.OID:
        case XfaElem.PICTURE:
        case XfaElem.REASON:
        case XfaElem.REF:
        case XfaElem.SCRIPT:
        case XfaElem.SPEAK:
        case XfaElem.SUBJECTDN:
        case XfaElem.TEXT:
        case XfaElem.TIME:
        case XfaElem.TOOLTIP:
            hasCData = true;
            break;
    }

    return hasCData;
};

/**
 * Returns the default value for XfaAtt.ALLOWRICHTEXT. Returns null if there isn't enough context.
 * @throws com.adobe.xfa.xfautil.Error Context node must be specified.
 * @throws com.adobe.xfa.xfautil.Error Attribute is not valid on the specified context node.
 */
XfaSchema._getAllowRichTextDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("Context node must be specified in order to determine " + XfaAtt.ALLOWRICHTEXT + " default.");
        return null;
    }

    if (contextNode.className != XfaElem.TEXTEDIT) {
        throw new Error(XfaAtt.ALLOWRICHTEXT + " is not a valid attribute on context node <" + contextNode.className + ">.");
        return null;
    }

    // Actual default depends on //value/{text|exData}

    // get <ui> node
    var parent = contextNode.parent;
    if (!parent) {
        return null;
    }

    // get field/draw node
    parent = parent.parent;
    if (!parent || (!(parent instanceof XfaField) && !(parent instanceof XfaDraw))) {
        return null;
    }

    if ((parent instanceof XfaField && parent.valueType == XfaElem.EXDATA) ||
        (parent instanceof XfaDraw && parent.valueType == XfaElem.EXDATA)) {
        return XfaSchema.ONE;
    }
    return XfaSchema.ZERO;
};

/**
 * Returns the default value for XfaAtt.CONTENTTYPE.
 * @throws com.adobe.xfa.xfautil.Error Context node must be specified.
 * @throws com.adobe.xfa.xfautil.Error Attribute is not valid on the specified context node.
 */
XfaSchema._getContentTypeDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("Context node must be specified in order to determine " + XfaAtt.CONTENTTYPE + " default.");
        return null;
    }

    switch (contextNode.className) {
        case XfaElem.EXDATA:
            return XfaMimeType.PLAINTEXT;
            break;

        case XfaElem.IMAGE:
            return XfaSchema.CDATA;
            break;

        case XfaElem.SCRIPT:
            return XfaVal.APPXFORMCALC;
            break;
    }

    throw new Error(XfaAtt.CONTENTTYPE + " is not a valid attribute on context node <" + contextNode.className + ">.");
    return null;
};

/**
 * Returns the default value for XfaAtt.INTACT.
 * @throws com.adobe.xfa.xfautil.Error Context node must be specified.
 * @throws com.adobe.xfa.xfautil.Error Attribute is not valid on the specified context node.
 */
XfaSchema._getIntactDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("Context node must be specified in order to determine " + XfaAtt.INTACT + " default.");
        return null;
    }

    if (contextNode.className != XfaElem.KEEP) {
        throw new Error(XfaAtt.INTACT + " is not a valid attribute on context node <" + contextNode.className + ">.");
        return null;
    }

    // From the XFA Schema: When the parent container is a subform and the subform's layout is flowing or table the default value is none.
    //  When the parent subform's layout is positioned or row the default value is contentArea. However when the parent container is a draw
    //  the default is always contentArea and when the parent is a field the default is always none.

    var parent = contextNode.parent;

    if (parent instanceof XfaSubform) {
        var layout = parent.getProperty(null, "@" + XfaAtt.LAYOUT);
        switch (layout) {
            case XfaVal.TB:
            case XfaVal.LRTB:
            case XfaVal.RLTB:
            case XfaVal.TABLE:
                return XfaVal.NONE;
                break;

            case XfaVal.POSITION:
            case XfaVal.ROW:
                return XfaVal.CONTENTAREA;
                break;

            default:
                // invalid layout attribute value
                break;
        }
    } else if (parent instanceof XfaField) {
        return XfaVal.NONE;
    } else if (parent instanceof XfaDraw) {
        return XfaVal.CONTENTAREA;
    }

    // unable to determine default from context node
    return null;
};

/**
 * Returns the default value for XfaAtt.MULTILINE.
 * @throws com.adobe.xfa.xfautil.Error Context node must be specified.
 * @throws com.adobe.xfa.xfautil.Error Attribute is not valid on the specified context node.
 */
XfaSchema._getMultiLineDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("Context node must be specified in order to determine " + XfaAtt.ALLOWRICHTEXT + " default.");
        return null;
    }

    if (contextNode.className != XfaElem.TEXTEDIT) {
        throw new Error(XfaAtt.MULTILINE + " is not a valid attribute on context node <" + contextNode.className + ">.");
        return null;
    }

    // One is the true default but actual default depends on //field vs //draw container element (see the spec).

    // get <ui> node
    var parent = contextNode.parent;
    if (!parent) {
        return null;
    }

    // get <field> or <draw> node
    parent = parent.parent;

    if (parent instanceof XfaField) {
        return XfaSchema.ZERO;
    } else if (parent instanceof XfaDraw) {
        return XfaSchema.ONE;
    }
    // unable to determine default from context node
    return null;
};

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var XmlUtil = ns.XmlUtil = {};

    XmlUtil.selectSingleNode = function (parent, localName, deep, occurrence) {
        deep = deep !== undefined ? deep : false;
        occurrence = isNaN(occurrence) ? 0 : occurrence;
        // Returns the first child node found with the given local name.
        var list = XmlUtil.selectNodes(parent, localName, deep);
        if (list && list.length() > occurrence) {
            return list[occurrence];
        } else {
            return null;
        }
    };
    XmlUtil.selectNodes = function (parent, localName, deep, attributeValue, attributeName, bExactMatch) {
        deep = deep !== undefined ? deep : false;
        attributeValue = attributeValue || null;
        attributeName = attributeName || "name";
        bExactMatch = bExactMatch !== undefined ? bExactMatch : true;
        if (parent == null) {
            return new XMLList();
        }
        var fullList;
        if (deep) {
            fullList = parent.descendants();
        } else {
            fullList = parent.elements();
        }

        return this.filterList(fullList, localName, attributeValue, attributeName, bExactMatch);
    };
    XmlUtil.filterList = function (fullList, localName, attributeValue, attributeName, bExactMatch) {
        attributeValue = attributeValue || null;
        attributeName = attributeName || "name";
        bExactMatch = bExactMatch !== undefined ? bExactMatch : true;
        var oList = new XMLList();

        for (var i = 0;
             i < fullList.length();
             i++) {
            var elem = fullList[i];
            if (localName == null || (elem.localName() != null && String(elem.localName()) == localName)) {
                // Element name matches - now check to see if an attribute needs to be matched as well.
                var bAdd = true;
                if (attributeValue) {
                    var attrMatch = XmlUtil.getAttribute(elem, attributeName);
                    if (!attrMatch) {
                        bAdd = false;
                    } else {
                        if (bExactMatch) {
                            if (attrMatch != attributeValue) {
                                //attribute values do not match
                                bAdd = false;
                            }
                        } else {
                            if (attrMatch.indexOf(attributeValue) == -1) {
                                //attribute value not found
                                bAdd = false;
                            }
                        }
                    }
                }
                if (bAdd) {
                    //add to list
                    oList.Append(elem);
                }
            }
        }
        return oList;
    };
    XmlUtil.getXmlObject = function (xmlobj, ignoreWhite, ignoreComments, ignorePIs) {
        ignoreWhite = ignoreWhite !== undefined ? ignoreWhite : false;
        ignoreComments = ignoreComments !== undefined ? ignoreComments : false;
        ignorePIs = ignorePIs !== undefined ? ignorePIs : false;
        var elem = null;

        if (!xmlobj) {
            return null;
        }

        if (xmlobj instanceof XMLList) {
            if (XMLList(xmlobj).length() > 0) {
                elem = xmlobj[0];
            }
        } else if (xmlobj instanceof XML) {
            elem = xmlobj;
        } else if (typeof xmlobj == "string") {
            // save settings
            var xmlSettings = XML.settings();

            // apply our own
            XML.ignoreWhitespace = ignoreWhite;
            XML.ignoreComments = ignoreComments;
            XML.ignoreProcessingInstructions = ignorePIs;

            try {
                elem = new XML(xmlobj);
            }
            catch (e) {
                //try wrapping with some root XML nodes
                try {
                    elem = new XML("<root>" + xmlobj + "</root>");
                } catch (e) {
                    //the string must contain incomplete XML so there
                    //is no way to convert it to an XML object
                    elem = null;
                }
            }

            // restore original settings
            XML.setSettings(xmlSettings);
        }

        return elem;
    };
    /**
     * Builds a path from a series of string arguments and calls selectNestedNode() with the resulting path.
     * <p>This is especially useful when you have string constants that you need to use instead of hardcoded
     *  strings. Typing <code>a,b,c</code> is much easier than typing <code>"/" + CONST_A + "/" + CONST_B + "/" + CONST_C</code>.
     *  With this function, you simply call <code>selectFromPath(parentXml, CONST_A, CONST_B, CONST_C);</code></p>
     * @param parentXml The element whose children and beyond will be searched.
     *  param arguments The string arguments that make-up the path. The result is in the form of <code>"/arg1/arg2/.../argN"</code>. Args
     *  names may be qualified with a namespace prefix as in <code>"prefix1:node1", "prefix2:node2", "node3"</code>.
     * @return An XML object representing the node referenced by the path or null if a match wasn't made.
     * @see #selectNestedNode()
     */
    XmlUtil.selectFromPath = function (parentXml) {
        parentXml = arguments[0];
        if (!parentXml) {
            return null;
        }

        var path = "";

        for (var i = 1;
             i < arguments.length;
             i++) {
            path += "/" + arguments[i].toString();
        }

        if (path) {
            return XmlUtil.selectNestedNode(parentXml, path);
        }

        return null;
    };
    XmlUtil.selectNestedNode = function (oParentElement, sPath) {
        if (oParentElement == null || sPath == null) {
            return null;
        }

        if (sPath.substr(0, 1) == "/") { // support optional leading "/"
            sPath = sPath.substr(1);
        }

        var toks = sPath.split("/");

        if (toks.length > 0) {
            var tok = toks[0]; // is either "name" or "prefix:name"

            var tokParts = tok.split(":"); // handle namespace prefix if specified
            var tokNsPrefix = (tokParts.length == 2 ? tokParts[0] : null);
            var tokName = (tokParts.length == 1 ? tokParts[0] : (tokParts.length == 2 ? tokParts[1] : null));
            if (null == tokName) {
                Debug.error("invalid token: " + tok);
                return null;
            }

            var elemList = oParentElement.elements();
            var item, i = 0;
            for (;
                i < elemList.length();
                i++) {
                item = elemList[i];
                if (item.localName() == tokName && (!tokNsPrefix || item.namespace(tokNsPrefix))) {
                    if (toks.length == 1) {
                        return item;
                    } else {
                        var oNode = XmlUtil.selectNestedNode(item, sPath.substring(sPath.indexOf(tok) + tok.length + 1));
                        if (oNode != null) {
                            return oNode;
                        }
                    }
                }
            }
            return null;
        }
        return null;
    };
    XmlUtil.decodeXmlChars = function (str, strict) {
        strict = strict !== undefined ? strict : false;
        if (str == null) {
            return null;
        }

        if (str.length == 0) {
            return "";
        }

        var dec = str; // the decoded string

        dec = dec.replace(new RegExp("&lt;", "g"), "<");
        dec = dec.replace(new RegExp("&gt;", "g"), ">");

        if (strict) {
            dec = dec.replace(new RegExp("&apos;", "g"), "'");
            dec = dec.replace(new RegExp("&quot;", "g"), "\"");
        }

        dec = dec.replace(new RegExp("&amp;", "g"), "&"); // do this *last* so that the ampersands in the previous codes don't get converted...
        return dec;
    };
    XmlUtil.encodeXmlChars = function (str, strict) {
        strict = strict !== undefined ? strict : false;
        if (str == null) {
            return null;
        }

        if (str.length == 0) {
            return "";
        }

        var enc = str; // encoded string

        enc = enc.replace(new RegExp("&", "g"), "&amp;"); // do this *first* so that the ampersands in the following inserted codes don't get converted...
        enc = enc.replace(new RegExp("<", "g"), "&lt;");
        enc = enc.replace(new RegExp(">", "g"), "&gt;");

        if (strict) {
            enc = enc.replace(new RegExp("'", "g"), "&apos;");
            enc = enc.replace(new RegExp('"', "g"), "&quot;");
        }

        return enc;
    };
    XmlUtil.getNodeText = function (xmlobj, deep, decode) {
        deep = deep !== undefined ? deep : true;
        decode = decode !== undefined ? decode : true;
        var node = XmlUtil.getXmlObject(xmlobj);

        if (!node) {
            if (typeof xmlobj == "string") {
                return decode ? XmlUtil.decodeXmlChars(String(xmlobj)) : String(xmlobj);
            } else {
                return "";
            }
        }

        if (node.hasSimpleContent()) {
            // always use XML.toString(), even if it decodes when we might not want it to, because it'll ensure that we get everything, including spaces,
            //  even if the content of the node is only whitespace
            var simpleContent = node.toString();
            if (!decode) {
                simpleContent = XmlUtil.encodeXmlChars(simpleContent);
            }

            return simpleContent;
        }

        //get all the node's children
        var childNode, sText = "";
        var list = node.children();

        for (var i = 0;
             i < list.length();
             i++) {
            childNode = list[i];
            switch (childNode.nodeKind()) {
                case XmlUtil.NODEKIND_TEXT :
                    sText += (decode ? childNode.toString() : childNode.toXMLString()); // XML.toString() decodes encoded XML characters
                    break;

                case XmlUtil.NODEKIND_ELEMENT :
                    if (deep) {
                        sText += XmlUtil.getNodeText(childNode, deep, decode); // recursive call
                    }
                    break;
            }
        }

        return sText;
    };

    XmlUtil.setNodeText = function (node, text, keepText, keepElements, keepComments, keepPIs) {

        keepText = keepText !== undefined ? keepText : false;
        keepElements = keepElements !== undefined ? keepElements : false;
        keepComments = keepComments !== undefined ? keepComments : false;
        keepPIs = keepPIs !== undefined ? keepPIs : false;
        if (!node) {
            return;
        }

        // Before assigning the new code, we have to extract all child elements we want to preserve
        //  otherwise they will be removed from the node's content. While they get removed from the
        //  content after setting the text, the nodes themselves don't get deleted (they just get
        //  de-referenced, I suppose) so they can easily be re-added as children.

        var content = keepText ? XmlUtil.getNodeText(node, false) : "";
        var elements = keepElements ? node.elements() : new XMLList();
        var comments = keepComments ? node.comments() : new XMLList();
        var pis = keepPIs ? node.processingInstructions() : new XMLList();

        // remove everything (same thing you would get if you used E4X to assign the text value to the node's content)
        XmlUtil.removeChildren(node);

        var xmlSettings = XML.settings();

        XML.ignoreWhitespace = false;
        XML.ignoreComments = false;
        XML.ignoreProcessingInstructions = false;

        // set the text content (in E4X, even though there are no children, you can still access the first child)
        if (null != text) {
            node.setChildren(content + text);
        }
        //node.children()[0] = content + text; // the XML class will automatically encode any XML characters in the text (except for apostrophes and quotation marks)

        var i, e, c, p;
        for (i = 0;
             i < elements.length();
             i++) {
            e = elements[i];
            node.appendChild(e, true);
        }
        for (i = 0;
             i < comments.length;
             i++) {
            c = comments[i];
            node.appendChild(c, true);
        }
        for (i = 0;
             i < pis.length;
             i++) {
            p = pis[i];
            node.appendChild(p, true);
        }

        XML.setSettings(xmlSettings);
    };
    XmlUtil.removeChildren = function (node) {
        XmlUtil.removeItems(node.children());
    };
    XmlUtil.removeNode = function (node) {
        if (!node) {
            return;
        }
        var nodeList = new XMLList(node);
        XmlUtil.removeItems(nodeList);
    };
    XmlUtil.removeItems = function (items) {
        var xmlList;
        if (items instanceof XML || items instanceof XMLList) {
            xmlList = items;
        }
        if (typeof items == "string") {
            xmlList = new XML(items);
        }
        if (xmlList) {
            for (var j = items.length() - 1;
                 j >= 0;
                 j--) {
                items.Delete(j);
            }
        }
    };
    XmlUtil.getParent = function (nodeXml) {
        return (nodeXml ? XmlUtil.getXmlObject(nodeXml.parent()) : null);
    };
    /**
     * Set an XML object's attribute value. The attribute will be removed
     * when the value is null.
     */
    XmlUtil.setAttribute = function (xmlobj, name, value) {
        if (!xmlobj || !name) {
            return;
        }

        var elem = XmlUtil.getXmlObject(xmlobj);
        if (elem != null) {
            if (value != null) {
                elem.Put('@' + name, value);
            } else {
                var list = elem.attribute(name);
                if (list && list.length() > 0) {
                    delete list[0];
                }
            }
        }
    };

    /**
     * Returns an XML object's attribute value. An empty string is returned if the attribute is not found unless an existence check is performed.
     * @param xmlobj
     * @param attrName Can be the local name (no namespace) only or a namespace qualifier may be specified (e.g. either "name" or "ns:name").
     * @param existenceCheck If true, null is returned when the attribute isn't specified (rather than an empty string).
     */
    XmlUtil.getAttribute = function (xmlobj, attrName, existenceCheck) {
        existenceCheck = existenceCheck !== undefined ? existenceCheck : false;
        var elem = XmlUtil.getXmlObject(xmlobj);

        if (elem && attrName) {
            var parts = attrName.split(":");
            var nsPrefix = (parts.length == 2 ? parts[0] : null);
            var localName = (parts.length == 1 ? parts[0] : (parts.length == 2 ? parts[1] : null));
            var attr, elementAttributes = elem.attributes();

            for (var index = 0;
                 index < elementAttributes.length();
                 index++) {
                attr = elementAttributes[index];
                if (attr.localName() == localName && (!nsPrefix || attr.inScopeNamespaces(nsPrefix))) {
                    // Attribute found
                    return attr.toString();
                }
            }
        }
        // Attribute not found
        return existenceCheck ? null : "";
    };
    XmlUtil.getPIXml = function (parent, domain, key, value) {
        value = value || null;
        if (!parent || !key || !domain) {
            return null;
        }

        var piList = parent.processingInstructions();
        var pi = null;

        for (var i = 0;
             i < piList.length;
             i++) {
            var piStr = piList[i].toString();
            var re = new RegExp(XmlUtil.PI_REGEXP, XmlUtil.PI_REGEXP_FLAGS);
            var matches = re.exec(piStr);

            //todo
            if (matches && matches.piDomain == domain && matches.piKey == key) {
                if (!value || matches.piValue == value) {
                    pi = piList[i];
                    break;
                }
            }
        }
        return pi;
    };

    XmlUtil.getPIXmlProperties = function (pi) {
        if (!pi) {
            return null;
        }

        var piStr = pi.toString();
        var re = new RegExp(XmlUtil.PI_REGEXP, XmlUtil.PI_REGEXP_FLAGS);
        var matches = re.exec(piStr);

        if (matches) {
            var props = {};
            props.domain = matches.piDomain;
            props.key = matches.piKey;
            if (matches.piValue) {
                props.value = matches.piValue;
            }
            return props;
        }
        return null;
    };

    /**
     * Searches the processing instructions on the specified node for a PI that has a matching domain and key. If a value is provided, the value will be matched as well.
     *  The search is case-sensitive.
     * @param parent XML node that contains the PIs to be searched.
     * @param pi Dynamic object with the following properties: "domain" (Required/String, the PI's domain), "key" (Required/String, the PI's key).
     * @param valueMatch Optional value to match as well. If specified, a &lt;?domain key valueMatch?&gt; PI must exist for the search to succeed. Specifying
     *  an empty string for this parameter will yield the same results as specifying null.
     * @return The PI's value (could be an empty string) if a matching PI was located, null otherwise.
     */
    XmlUtil.findPIObj = function (parent, pi, valueMatch) {
        valueMatch = valueMatch || null;
        if (!parent) {
            return null;
        }

        if (!pi.hasOwnProperty("domain") || !pi.hasOwnProperty("key")) {
            Debug.error("missing required properties in pi object: 'domain' and 'key'");
            return null;
        }

        var piXml = XmlUtil.getPIXml(parent, pi.domain, pi.key, valueMatch);
        if (piXml) {
            return XmlUtil.getPIXmlValue(piXml);
        }

        return null;
    };
    /**
     * Returns the value of a &lt;?domain key value?&gt; PI. The value may contain (or be) whitespace but the domain and key must not.
     * @param pi XML object representing the PI whose value is to be returned.
     * @return The PI's value as a string. If the PI doesn't have a value, an empty string is returned. If the PI doesn't have a domain and key, null is returned.
     */
    XmlUtil.getPIXmlValue = function (pi) {
        if (!pi) {
            return null;
        }
        var props = XmlUtil.getPIXmlProperties(pi);
        if (props) {
            return props.hasOwnProperty("value") ? props.value : "";
        }

        return null;
    };

    /**
     * Returns the value of a &lt;?domain key value?&gt; PI. The value may contain (or be) whitespace but the domain and key must not.
     * @param pi XML object representing the PI whose value is to be returned.
     * @return The PI's value as a string. If the PI doesn't have a value, an empty string is returned. If the PI doesn't have a domain and key, null is returned.
     */
    XmlUtil.getPIXmlValuefunction = function (pi) {
        if (!pi) {
            return null;
        }
        var props = XmlUtil.getPIXmlProperties(pi);
        if (props) {
            return props.hasOwnProperty("value") ? props.value : "";
        }

        return null;
    };

    /**
     * Determines the qualified name of the node (namespace <b>prefix</b> added if the node has a namespace). This differs from the QName object
     *  which prints URI::localName (prints the URI rather than the prefix and uses double colons rather than a single).
     * @param nodeXml The node whose qualified name is to be printed.
     * @return The qualified name (includes namespace prefix if node has namespace) or empty string if node is null or isn't an element or attribute.
     */
    XmlUtil.qualifiedName = function (nodeXml) {
        if (!nodeXml || (nodeXml.nodeKind() != XmlUtil.NODEKIND_ELEMENT && nodeXml.nodeKind() != XmlUtil.NODEKIND_ATTRIBUTE)) {
            return "";
        }

        var name = "";
        var ns = nodeXml.namespace();

        if (ns) {
            if (typeof ns.prefix == 'undefined') {
                // It seems that there are cases when an element or attribute may have a namespace prefix but the namespace isn't defined anywhere in the XML document.
                //  Strange but true. Perhaps it's OK when the namespace prefix is a well-know prefix like "xml" which is why the Namespace object, in that case,
                //  contains an undefined prefix but manages to produce a uri of "http://www.w3.org/XML/1998/namespace".
                // Example: In an XMP packet inside an XDP, you'll find <rdf:li xml:lang="x-default">{title}</rdf:li> where "xml" is not defined in the XDP doc.
                if (ns.uri == "http://www.w3.org/XML/1998/namespace") {
                    name += "xml:";
                }
            } else if (ns.prefix != "") {
                name += ns.prefix + ":";
            }
        }
        name += nodeXml.localName();
        return name;
    };

    /**
     * Prints the attributes specified on the XML node.
     * @param nodeXml The element whose attributes are to be printed.
     * @return The printed version of the XML node's attributes, all on a single line. If the node has no attributes, an empty string is returned.
     */
    XmlUtil._printXmlAttributes = function (nodeXml) {
        if (!nodeXml || nodeXml.nodeKind() != XmlUtil.NODEKIND_ELEMENT) {
            return "";
        }

        var print = "";
        var attList = nodeXml.attributes();

        for (var i = 0;
             i < attList.length();
             i++) {
            var attXml = attList[i];
            if (print.length > 0) {
                print += " ";
            }

            print += XmlUtil.qualifiedName(attXml);
            // strict=true in the following encoding function so that it encodes for all five characters (&,',",<,>)
            // This is necessary because toString() function decodes all five characters.
            var value = null;
            if (attXml) {
                if (typeof attXml.toXMLString === "function") {
                    value = attXml.toXMLString();
                } else {
                    value = attXml.toString();
                }
            }
            print += '="' + XmlUtil.encodeXmlChars(XmlUtil.decodeXmlChars(value, true), true) + '"';
        }
        return print;
    };

    /**
     * Prints an XML element.
     * @param nodeXml The element to print.
     * @param indentStr The indentation string to prepend to the printed output.
     * @param printOpen True if the opening of the element should be printed; false if the closing should be printed. If true and the node
     *  has no children, the node is printed as a closed element (e.g. &lt;elem/&gt;).
     * @return The printed version of the XML element. If the node is null, an empty string is returned.
     */
    XmlUtil._printXmlElement = function (nodeXml, indentStr, printOpen) {
        if (!nodeXml || nodeXml.nodeKind() != XmlUtil.NODEKIND_ELEMENT) {
            return "";
        }
        var print = "<";
        if (!printOpen) {
            print += "/";
        }
        // -- print the qualified name
        print += XmlUtil.qualifiedName(nodeXml);

        if (printOpen) {

            //Adding default namespace
            var ns = nodeXml._DefaultNamespace;
            if (ns && ns.uri && XmlUtil.qualifiedName(nodeXml) == "body") {
                print += " xmlns=\"" + ns.uri + "\" ";
            }

            // print the opening of the element
            // -- print the namespaces
            // this will list only new namespaces; in-scope namespaces will not be in this list
            var nsList = nodeXml.namespaceDeclarations();
            var nsScopeList = nodeXml.inScopeNamespaces();

            for (var i = 0;
                 i < nsList.length;
                 i++) {
                var ns = nsList[i];
                // add namespace declaration
                print += " xmlns";
                // check for default namespace
                if (ns.prefix != "") {
                    print += ":" + ns.prefix;
                }
                print += '="' + ns.uri + '"';
            }
            // -- print the attributes
            var atts = XmlUtil._printXmlAttributes(nodeXml);
            if (atts.length > 0) {
                print += " " + atts;
            }
            // -- postfix
            // if no children, close the node
            if (nodeXml.children().length() == 0) {
                print += "/";
            }
            print += ">";
        } else {
            // print the closing of the element
            print += ">";
        }
        return indentStr + print;
    };

    /**
     * Recursive helper function to XmlUtil.print().
     * @param nodeXml The XML node to print.
     * @param options Print options. Expected properties are as follows:
     *  <p>pretty: Boolean indicating whether to pretty-print or not.</p>
     *  <p>indent: int specifying the depth to indent when pretty-printing.</p>
     *  <p>level: int specifying the current level of recursion.</p>
     *  <p>filter: Function to call to filter nodes. Can be null.</p>
     * @return The printed version of the XML node (could be an empty string). Null if the node was filtered-out. Empty string if nodeXml was null.
     * @see #print()
     */
    XmlUtil._printXmlNode = function (nodeXml, options) {
        if (!nodeXml) {
            return "";
        }

        var print = "";
        var indentStr = options.pretty ? XmlUtil.repeat(XmlUtil._PRETTYPRINT_INDENT_CHAR, options.indent * options.level) : "";
        var prettyInside = options.pretty;
        var filterOptions = null;

        if (options.filter != null) {
            filterOptions = {prettyInside : prettyInside, keep : true};

            if (options.filter.call(null, nodeXml, filterOptions) == true) {
                if (!filterOptions.keep) {
                    return null;
                }
                prettyInside = filterOptions.prettyInside;
            } else {
                filterOptions = null;
            }
        }

        switch (nodeXml.nodeKind()) {
            case XmlUtil.NODEKIND_ELEMENT :
                // use this node's pretty setting
                print += ((print.length > 0 && options.pretty) ? "\n" : "") + XmlUtil._printXmlElement(nodeXml, indentStr, true);

                // use the children's pretty setting (prettyInside)
                if (nodeXml.children().length() > 0) {
                    if (nodeXml.children().length() == 1 && nodeXml.children()[0].nodeKind() == XmlUtil.NODEKIND_TEXT && filterOptions == null) {
                        // Override the pretty setting for children if there's only one, it's a text node and the filter function didn't explicitly
                        //  request that the contents of this node be pretty-printed.
                        // XML parsers typically output elements with a single text node all on a single line. This ensures that whitespace within text nodes remains intact.
                        // WARNING: Disabling this will lead to unexpected behaviour. For example, Designer crashes when "pasting the print-out into XML Source, going to Design
                        //  View and then back to XML Source" if this override is not applied.
                        prettyInside = false;
                    }

                    // Make a copy and apply settings for children on the copy since objects are passed by reference.
                    // WARNING: Do not use ObjectUtil.copy() because it won't copy the filter property for some reason (perhaps it only clones properties that are primitive types?).
                    var insideOptions = {pretty : prettyInside, indent : options.indent, level : options.level + 1, filter : options.filter};

                    var insidePrint = "";
                    var childElements = nodeXml.children();
                    for (var i = 0;
                         i < childElements.length();
                         i++) {
                        var child = childElements[i];
                        var childPrint = XmlUtil._printXmlNode(child, insideOptions); // recursive call
                        if (childPrint != null) {
                            insidePrint += ((insidePrint.length > 0 && prettyInside) ? "\n" : "") + childPrint;
                        }
                    }

                    // add the inside printed content (if any) to the print content, closing node the appropriate way
                    if (insidePrint.length > 0) {
                        // add inside content and close with </node> syntax
                        print += ((print.length > 0 && prettyInside) ? "\n" : "") + insidePrint;
                        print += ((print.length > 0 && prettyInside) ? "\n" : "") + XmlUtil._printXmlElement(nodeXml, prettyInside ? indentStr : "", false);
                    } else {
                        // no children were printed -- close with <node/> syntax
                        print = print.substring(0, print.length - 1) + "/>";
                    }
                }
                break;

            case XmlUtil.NODEKIND_ATTRIBUTE :
                Debug.warning("skipping attribute node '" + XmlUtil.qualifiedName(nodeXml) + "': these should be handled when printing elements", null);
                break;

            case XmlUtil.NODEKIND_COMMENT :
                print += ((print.length > 0 && options.pretty) ? "\n" : "") + XmlUtil._printXmlComment(nodeXml, indentStr);
                break;

            case XmlUtil.NODEKIND_PI :
                print += ((print.length > 0 && options.pretty) ? "\n" : "") + XmlUtil._printXmlPI(nodeXml, indentStr);
                break;

            case XmlUtil.NODEKIND_TEXT :
                print += ((print.length > 0 && options.pretty) ? "\n" : "") + XmlUtil._printXmlText(nodeXml, indentStr);
                break;

            default:
                Debug.warning("skipping unsupported node kind: " + nodeXml.nodeKind(), null);
                break;
        }
        return print;
    };

    /**
     * Prints an XML comment.
     * @param nodeXml The comment to print.
     * @param indentStr The indentation string to prepend to the printed output.
     * @return The printed version of the XML comment. If the node is null, an empty string is returned.
     */
    XmlUtil._printXmlComment = function (nodeXml, indentStr) {
        if (!nodeXml || nodeXml.nodeKind() != XmlUtil.NODEKIND_COMMENT) {
            return "";
        }

        // use toXMLString() to get the full mark-up
        var print = nodeXml.toXMLString();
        return indentStr + print;
    };
    /**
     * Prints an XML processing instruction.
     * @param nodeXml The processing instruction to print.
     * @param indentStr The indentation string to prepend to the printed output.
     * @return The printed version of the XML processing instruction. If the node is null, an empty string is returned.
     */
    XmlUtil._printXmlPI = function (nodeXml, indentStr) {
        if (!nodeXml || nodeXml.nodeKind() != NODEKIND_PI) {
            return "";
        }

        // use toXMLString() to get the full mark-up
        var print = nodeXml.toXMLString();
        return indentStr + print;
    };
    /**
     * Prints XML text.
     * @param nodeXml The text to print.
     * @param indentStr The indentation string to prepend to the printed output.
     * @return The printed version of the XML text. If the node is null, an empty string is returned.
     */
    XmlUtil._printXmlText = function (nodeXml, indentStr) {
        if (!nodeXml || !nodeXml.toString() || nodeXml.nodeKind() != XmlUtil.NODEKIND_TEXT) {
            return "";
        }

        // use toString() to get just the text, including spaces, then re-encode the text
        var print = XmlUtil.encodeXmlChars(nodeXml.toString());
        // fix-up cases where we have CRLF sequences since outputting those causes double-spaced text
        print = print.replace("\r\n", "\n");
        return indentStr + print;
    };
    /**
     * Finds the child element at the specified occurrence.
     * @param parentXml The parent XML node whose immediate children (only) will be searched.
     * @param elemName Class name of the child element sought.
     * @param occurrence The occurrence of the child element sought.
     * @param create If true and there are less existing occurrences of the specified child than the occurrence specified, the
     *  missing child elements will be created and appended to the parent node.
     * @return The child element sought (may be a new child of the parent if <code>create</code> was true). If <code>create</code> was false
     *  and the occurrence wasn't found, null.
     */
    XmlUtil.getChildOccurrence = function (parentXml, elemName, occurrence, create) {
        occurrence = occurrence !== undefined ? occurrence : 0;
        create = create !== undefined ? create : false;
        if (occurrence < 0) {
            return null;
        }

        var elemXml = null;

        var occur = -1; // current occurrence of existing elements with class names that match elemName
        var children = parentXml.elements();
        for (var i = 0;
             i < children.length();
             i++) {
            var childXml = children[i];
            if (childXml.localName() == elemName) {
                occur++;
                if (occur == occurrence) {
                    // found node sought
                    elemXml = childXml;
                    break;
                }
            }
        }

        if (!elemXml && create) {
            // add missing occurrences
            for (var j = 0;
                 j < (occurrence - occur);
                 j++) {
                elemXml = XmlUtil.addChildElement(parentXml, elemName);
            }
        }
        return elemXml;
    };
    /**
     * Returns a child element from its parent optionally creating and parenting it if it doesn't exist.
     * @param localnameOrIndex Can either be a string or a number.  When it's is a number an indexed search is performed otherwise the first element whose local
     *  name matches localnameOrIndex is returned.
     *  @param parent
     * @param create If true and the element is not found and localnameOrIndex is a string, a new element with localnameOrIndex as the local name is created and
     *  appended to the parent object.
     */
    XmlUtil.getChildElement = function (parent, localnameOrIndex, create) {
        create = create !== undefined ? create : false;
        var xmlParent = XmlUtil.getXmlObject(parent);

        if (!xmlParent) {
            return null;
        }

        var oNode = null;

        if (typeof localnameOrIndex == "number") {
            //Search by index
            var index = Number(localnameOrIndex);
            var children = xmlParent.elements();
            if (index < children.length() && index >= 0) {
                oNode = children[index];
            }
        } else {
            //Search by element name
            oNode = XmlUtil.selectSingleNode(xmlParent, localnameOrIndex);
            if (!oNode && create) {
                oNode = XmlUtil.addChildElement(xmlParent, localnameOrIndex);
            }
        }
        return oNode;
    };
    /**
     * Creates a new XML element with an optional name attribute and
     * appends it to the parent element.
     */
    XmlUtil.addChildElement = function (parent, elemName, name) {
        if (!parent || !elemName) {
            return null;
        }

        var oNode;
        if (name) {
            oNode = XmlUtil.createTag(elemName, {name : name});
        } else {
            oNode = XmlUtil.createTag(elemName, null);
        }
        parent.appendChild(oNode, true);
        return oNode;
    };
    XmlUtil.createTag = function (element, paramaters) {
        var name, xml, xmlString = "<" + element;
        if (paramaters) {
            for (name in
                paramaters) {
                xmlString += " " + name + "=\"" + paramaters[name] + "\"";
            }
        }
        xmlString += " />";
        xml = new XML(xmlString);
        return xml;
    };

    /**
     * Prints the specified XML node. This function differs from AS3's <code>XML.toXMLString()</code> function in that it has special handling for certain
     *  cases like unqualified namespace prefixes (where a namespace prefix is used when there's no definition for that prefix in the XML document). Whitespace,
     *  comments and processing instructions are always preserved.
     * @param rootXml The XML node to print.
     * @param options Optional object specifying the following optional properties:
     *  <p>pretty: Boolean. True if the printing should be pretty; false if it should be on a single line. Default: false.</p>
     *  <p>indent: int. The depth to indent new child lines when pretty-printing. Default: 2.</p>
     *  <p>filter: Function. Default: null. Function that is called prior to processing any type of node providing the ability to direct the algorithm on
     *   specific nodes. The function's signature is expected to be <code>function(node:XML, options:Object)</code> where node is the XML node about
     *   to be processed and options is a dynamic object used to pass in the current state and to pass out any state modifications. If the filter function
     *   returns true, the options will be considered, otherwise they will be ignored and the algorithm will continue its default processing. The options
     *   object has the following properties: <code>prettyInside</code> (Boolean set to the current state of <code>pretty</code>), <code>keep</code>
     *   (Boolean that defaults to true and determines whether the node should be included in the print-out or not). Default: null.</p>
     * @return The (pretty) printed version of the XML node. If rootXml is null, an empty string is returned.
     */
    XmlUtil.print = function (rootXml, options) {
        // There's a problem with the way the Flex XML class handles namespaces which aren't qualified. The output is valid but Designer 8.1+ crashes
        //  as a result of parsing it. Designer 8.2 will contain a fix for this.
        // In the XMP Metadata packet, the following node is defined:
        //  <rdf:li lang="x-default" xmlns="http://www.w3.org/XML/1998/namespace">
        // Defining this way results in invalid XML (at least most XML parsers don't like it). It's expecting it to be defined in this way:
        //  <rdf:li xml:lang="x-default">
        // (Notice that the Flex XML class is automatically qualifying the "xml" namespace with some default which the other parser doesn't like.)
        // This is one difference in the way this print function outputs the XML as opposed to how AS3's XML.toXMLString() does it.

        options = options || null;

        // initialize to default values
        var printOptions = {pretty : false, indent : 2, filter : null, level : 0};

        if (options) {
            if (options.hasOwnProperty("pretty")) {
                printOptions.pretty = options.pretty;
            }

            if (options.hasOwnProperty("indent")) {
                printOptions.indent = options.indent;
            }

            if (options.hasOwnProperty("filter")) {
                printOptions.filter = options.filter;
            }
        }

        var print = XmlUtil._printXmlNode(rootXml, printOptions);

        // always return a string
        return print ? print : "";
    };

    /** Returns a string whose content is the string c repeated count times. If c is null, the returned string is null. */
    XmlUtil.repeat = function (c, count) {
        var s = "";
        if (c == null) {
            return s;
        }
        for (var i = 0;
             i < count;
             i++) {
            s += c;
        }
        return s;
    };

    XmlUtil.getAllChildren = function (parentXML) {
        if (parentXML != null) {
            return parentXML._Children;
        }
    };

    XmlUtil.XHTMLNSURI = "http://www.w3.org/1999/xhtml";
    XmlUtil.NODEKIND_TEXT = "text";
    XmlUtil.NODEKIND_ELEMENT = "element";
    XmlUtil.NODEKIND_COMMENT = "comment";
    XmlUtil.NODEKIND_PI = "processing-instruction";
    XmlUtil.NODEKIND_ATTRIBUTE = "attribute";
    XmlUtil.PI_REGEXP = "<\\?(?P<piDomain>\\S+)\\s+(?P<piKey>\\S+)(?:\\s?)(?P<piValue>.*)\\?>";
    XmlUtil.PI_REGEXP_FLAGS = "gs";
    XmlUtil._PRETTYPRINT_INDENT_CHAR = " ";
})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2015. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var XfaUtil = ns.XfaUtil = {};

    /**
     * Prints the specified XFA node prodiving special handling for specific XFA nodes to preserve white space where it's needed (e.g. XHTML).
     * @param rootXfa The XFA XML node to print.
     * @param options Optional object specifying the following optional properties:
     *  <p>pretty: Boolean. True if the printing should be pretty; false if it should be on a single line. Default: false.</p>
     *  <p>indent: int. The depth to indent new child lines when pretty-printing. Default: 2.</p>
     * @return The (pretty) printed version of the XFA node. If rootXml is null, an empty string is returned.
     */
    XfaUtil.print = function (rootXfa, options) {
        var printOptions = {pretty : false, indent : 2, filter : this._printXfaFilter};
        if (options) {
            if (options.hasOwnProperty("pretty")) {
                printOptions.pretty = options.pretty;
            }
            if (options.hasOwnProperty("indent")) {
                printOptions.indent = options.indent;
            }
        }
        return ns.XmlUtil.print(rootXfa, printOptions);
    };

    XfaUtil._printXfaFilter = function (nodeXml, options) {
        var applyOptions = false;

        if (nodeXml && nodeXml.nodeKind() == ns.XmlUtil.NODEKIND_ELEMENT) {
            if (ns.XmlUtil.findPIObj(nodeXml, {domain : XfaUtil.PI_DOMAIN, key : "transientNode"}, null) != null) {
                // node is transient -- don't keep it
                options.keep = false;
                applyOptions = true;
            } else if (nodeXml.localName() == 'body') {
                var defaultNs = nodeXml.namespace();

                if (defaultNs && defaultNs.prefix == "" && defaultNs.uri == ns.XmlUtil.XHTMLNSURI && nodeXml.namespace('xfa') != 'undefined') {
                    // never pretty-print the XHTML
                    options.prettyInside = false;
                    applyOptions = true;
                }
            }
        }

        return applyOptions;
    };
    /**
     * Properly handles loading an XFA XML string into AS3's E4X XML object. XFA documents are usually pretty-printed which means whitespace must be ignored however
     *  they may contain some XHTML in which spaces must be preserved. AS3's XML object provides a way to ignore whitespace however it causes the whitespace within
     *  the XHTML to be ignored when it's critical to preserve it. This function handles the two different kinds of whitespace appropriately, making sure that the
     *  whitespace we don't want is discarded and the whitespace we do want is preserved.
     * @param sourceStr The string containing the (XFA) XML definition (may be an entire document (i.e. an XDP), a piece of XFA, or some arbitrary XML). Note that
     *  this even works with source strings which are not XML. If a non-XML source string is provided, the result will be an XML object with the string as its text
     *  (a text node, essentially, as per the top-level XML object's constructor output).
     * @return The XML object based on the specified string or null if an error occurred.
     */
    XfaUtil.load = function (sourceStr) {
        var xfaStr = sourceStr; // indirection simply to change the exposed parameter name without touching the code inside
        if (!xfaStr) {
            return null;
        }

        // space substitution character
        var spaceSubChar = 'x';

        //
        // Step 1: Replace each space in spaceruns with "x" characters.
        //
        var spacerunStyle = "xfa-spacerun : yes";
        var spacerunStart = '<span style="' + spacerunStyle + '">';
        var spacerunEnd = '</span>';

        // use global flag so we can iterate over matches using re.lastIndex as start for next search
        // handle extra whitespace in between element name and attribute on open and close tags
        var spacerunRE = XRegExp('/<\\s*?span\\s*?style="xfa-spacerun:yes"\\s*?>(\\s+)<\/\\s*?span\\s*?>/', 'gis');
        var spacerunMatch = spacerunRE.exec(xfaStr);
        var spacerunCount = 0;

        while (spacerunMatch) {
            spacerunCount++;
            // replace the spaces in the match with the same number of "x" characters
            xfaStr = xfaStr.substring(0, spacerunMatch.index) + spacerunStart + StringHelper.repeat(spaceSubChar, spacerunMatch[1].length) + spacerunEnd + xfaStr.substr(spacerunRE.lastIndex);
            // look for more matches
            spacerunMatch = spacerunRE.exec(xfaStr);
        }

        //
        // Step 2: Protect single spaces at the start and end of text nodes. These aren't marked as spaceruns (which contain 2 or more consecutive spaces or, in some exceptions,
        //         a single space, e.g. to indicate an empty paragraph) and they'll be removed when we load ignoring whitespace in the next step.
        //

        // this isn't an official style -- I just made this up hoping it's unique
        var singlerunStyle = spacerunStyle + ";loader-singlerun:yes";
        var singlerunStr = '<span style="' + singlerunStyle + '">' + spaceSubChar + '</span>';

        var singlerunRE = new RegExp();
        var bodyStartRE = XRegExp('<\\s*?body\\s.+?>', 'gis'); // handle whitespace before "body" and require 1 whitespace char after and then some content (namespaces) before closing '>'
        var bodyEndRE = XRegExp('<\/\\s*?body\\s*?>', 'gis'); // handle whitespace before and after "body"
        var bodyStartMatch = bodyStartRE.exec(xfaStr);
        var bodyEndMatch = bodyEndRE.exec(xfaStr);
        var singlerunCount = 0;

        while (bodyStartMatch && bodyEndMatch && bodyStartRE.lastIndex < bodyEndMatch.index) {
            // found a body node with contents
            // up to and including <body ...>
            var preBodyStr = xfaStr.substring(0, bodyStartRE.lastIndex);
            // content between <body ...> and </body>
            var contentStr = xfaStr.substring(bodyStartRE.lastIndex, bodyEndMatch.index);
            // </body> and the rest
            var postBodyStr = xfaStr.substr(bodyEndMatch.index);

            // space at start of text node
            var startRE = new RegExp('> \S', 'gi');

            // match single spaces at start of text nodes
            var startMatch = startRE.exec(contentStr);
            var spaceCounter = 0; // Count no. of space replaced
            while (startMatch) {
                singlerunCount++;
                spaceCounter++;
                // pattern will match one character preceding and one following the single space which must be preserved
                contentStr = contentStr.substring(0, startMatch.index + 1) + singlerunStr + contentStr.substr(startRE.lastIndex - 1);
                startMatch = startRE.exec(contentStr);
            }

            // space at end of text node
            var endRE = new RegExp('\S <', 'gi');

            // match single spaces at end of text nodes
            var endMatch = endRE.exec(contentStr);
            while (endMatch) {
                singlerunCount++;
                spaceCounter++;
                // pattern will match one character preceding and one following the single space which must be preserved
                contentStr = contentStr.substring(0, endMatch.index + 1) + singlerunStr + contentStr.substr(endRE.lastIndex - 1);
                endMatch = endRE.exec(contentStr);
            }
            // rebuild the XFA string with the new contents containing the substitutions
            xfaStr = preBodyStr + contentStr + postBodyStr;
            bodyStartRE.lastIndex += (spaceCounter * singlerunStr.length) - spaceCounter;
            bodyEndRE.lastIndex += (spaceCounter * singlerunStr.length) - spaceCounter;
            // look for more <body ...>...</body> matches
            bodyStartMatch = bodyStartRE.exec(xfaStr);
            bodyEndMatch = bodyEndRE.exec(xfaStr);
        }
        //
        // Step 3: Load the XFA ignoring whitespace.
        //
        // save current settings
        var xmlSettings = XML.settings();
        XML.ignoreComments = false;
        XML.ignoreProcessingInstructions = false;
        XML.ignoreWhitespace = true;
        var xfaXml = null;
        try {
            // Removing version details to resolve Error (Error : XML declaration allowed only at the start of the document)
            xfaStr = xfaStr.replace(/\s*\<\?xml.*?\?\>/i, "");
            // Replace all non-breakable space to space unicode in case of IE10 as ActiveX loadXml is failing in xbe4x
            if (ns.RTEUtils.isIE()) {
                xfaStr = xfaStr.replace(/\&nbsp\;/g, "&#160;");
            }
            xfaXml = new XML(xfaStr);
        }
        catch (err) {
            alert("exception " + err);
            // fail silently since caller may be testing string as being valid XML
        }
        // restore previous settings
        XML.setSettings(xmlSettings);
        //
        // Step 3: Restore the substituted spaces in the XML.
        var i;
        if (xfaXml) {
            var runXml = null;
            // restore spaceruns
            if (spacerunCount > 0) {
                var spacerunList = ns.XmlUtil.selectNodes(xfaXml, "span", true, spacerunStyle, "style", true);
                if (spacerunList.length() != spacerunCount) {
                    window.console.warn("found " + spacerunCount + " spacerun matches but found " + spacerunList.length() + " spacerun nodes", null);
                }

                for (i = 0;
                     i < spacerunList.length();
                     i++) {
                    runXml = spacerunList[i];
                    var text = ns.XmlUtil.getNodeText(runXml);
                    ns.XmlUtil.setNodeText(runXml, StringHelper.repeat(" ", text.length));
                }
            }

            // restore our custom "singleruns"
            if (singlerunCount > 0) {
                var singlerunList = ns.XmlUtil.selectNodes(xfaXml, "span", true, singlerunStyle, "style", true);
                if (singlerunList.length() != singlerunCount) {
                    window.console.warn("found " + singlerunCount + " singlerun matches but found only " + singlerunList.length() + " singlerun nodes", null);
                }

                var ignoreWhite = false;
                XML.ignoreWhitespace = false;
                // text node with a single space
                var singleXml = new XML("<span> </span>");
                // insert single space text node as a sibling of each singlerun node
                for (i = 0;
                     i < singlerunList.length();
                     i++) {
                    runXml = singlerunList[i];
                    var runParentXml = ns.XmlUtil.getParent(runXml);
                    if (runParentXml) {
                        runParentXml.insertChildAfter(runXml, singleXml);
                    }
                }
                // remove the singlerun node
                for (i = 0;
                     i < singlerunList.length();
                     i++) {
                    runXml = singlerunList[i];
                    let children = ns.XmlUtil.getAllChildren(runParentXml);
                    for (let j = children.length - 1; j >= 0 ; j--) {
                        if (children[j] != null && runXml === children[j]) {
                            delete children[j];
                        }
                    }
                }
                // remove all singleruns from the XML
                // ns.XmlUtil.removeItems(singlerunList);
                $(singlerunList).empty();

                // restore original whitespace flag
                XML.ignoreWhitespace = ignoreWhite;
            }
        }
        return xfaXml;
    };
    XfaUtil.getNodeText = function (xmlobj, deep, decode) {
        deep = deep !== undefined ? deep : true;
        decode = decode !== undefined ? decode : true;

        var node = this.getXmlObject(xmlobj);

        if (!node) {
            if (typeof xmlobj == "string") {
                return decode ? ns.XmlUtil.decodeXmlChars(String(xmlobj)) : String(xmlobj);
            } else {
                return "";
            }
        }

        if (node.hasSimpleContent()) {
            // always use XML.toString(), even if it decodes when we might not want it to, because it'll ensure that we get everything, including spaces,
            //  even if the content of the node is only whitespace
            var simpleContent = node.toString();
            if (!decode) {
                simpleContent = ns.XmlUtil.encodeXmlChars(simpleContent);
            }

            return simpleContent;
        }

        //get all the node's children
        var childNode, sText = "";
        var list = node.children();

        for (var i = 0;
             i < list.length;
             i++) {
            childNode = list[i];
            switch (childNode.nodeKind()) {
                case ns.XmlUtil.NODEKIND_TEXT:
                    sText += (decode ? childNode.toString() : childNode.toXMLString()); // XML.toString() decodes encoded XML characters
                    break;

                case ns.XmlUtil.NODEKIND_ELEMENT:
                    if (deep) {
                        sText += ns.XmlUtil.getNodeText(childNode, deep, decode); // recursive call
                    }
                    break;
            }
        }
        return sText;
    };

    XfaUtil.PI_DOMAIN = "xfalib";
    XfaUtil.NODEKIND_TEXT = "text";
    XfaUtil.NODEKIND_ELEMENT = "element";
    XfaUtil.NODEKIND_COMMENT = "comment";
    XfaUtil.NODEKIND_PI = "processing-instruction";
    XfaUtil.NODEKIND_ATTRIBUTE = "attribute";
    XfaUtil.PI_REGEXP = "<\\?(?P<piDomain>\\S+)\\s+(?P<piKey>\\S+)(?:\\s?)(?P<piValue>.*)\\?>";
    XfaUtil.PI_REGEXP_FLAGS = "gs";
    XfaUtil._PRETTYPRINT_INDENT_CHAR = " ";

})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var XfaRichTextUtil = ns.XfaRichTextUtil = function () {

        this.error = null;
    };

    /**
     * Tests the supplied string to determine if it only contains plain text and no XML elements, comments, processing instructions, etc.
     * @param value The string to test for plain text.
     * @return True if <code>value</code> is plain text; false if not.
     */
    XfaRichTextUtil.isPlainText = function (value) {
        var plain = ns.XmlUtil.getXmlObject(value);

        if (plain) {
            return (plain.nodeKind() == ns.XmlUtil.NODEKIND_TEXT);
        }
        return false;
    };

    /**
     * Tests the supplied string to determine if it is valid XFA rich text. All XFA rich text must be valid XML and have one of the following
     *  top-level container nodes:
     * <ul>
     * <li>exData -- only if includeExData is true (XFA node, in XML form, expected to contain rich text content)</li>
     * <li>html</li>
     * <li>body</li>
     * <li>p</li>
     * </ul>
     * @param value Can be either a String (which is converted to XML) or XML.
     * @param includeExData If true, &lt;exData&gt; XML nodes are considered as rich text.
     * @return True if the value is assumed to be (or contain, in the case of &lt;exData&gt;) rich text; false otherwise.
     */
    XfaRichTextUtil.isXfaRichText = function (value, includeExData) {
        includeExData = includeExData !== undefined ? includeExData : true;

        if (value == null || !(typeof value == "string" || value instanceof XML)) {
            return false;
        }

        var xfa = (value instanceof XML) ? value : ns.XfaUtil.load(value);

        if (xfa && xfa.nodeKind() == ns.XmlUtil.NODEKIND_ELEMENT) {
            if ((xfa.localName() == XfaElem.EXDATA && includeExData) ||
                xfa.localName() == "html" ||
                xfa.localName() == XfaXhtml.BODY || xfa.localName() == "p") {
                return true;
            }
        }
        return false;
    };

    /**
     * Creates an array of style objects form a given CSS string.
     * @param styleString The string to convert.
     * @return An array where each element is an object with the following dynamic properties:
     *  <ul>
     *   <li>styleName (String): The name of the style.</li>
     *   <li>styleValue (String): The value of the style.</li>
     *  </ul>
     */
    XfaRichTextUtil.createStyleArray = function (styleString) {
        if (!styleString) {
            return [];
        }

        var sStyleArray = styleString.split(";");
        var styleObjArray = [];

        for (var j = 0;
             j < sStyleArray.length;
             j++) {
            var sStyle = sStyleArray[j];
            // Skip empty style
            if (!sStyle) {
                continue;
            }

            var nameValue = sStyle.split(":");
            if (nameValue.length != 2) {
                window.console.warn(sStyle + " is not formatted correctly: skipped", null);
                continue;
            }
            var sStyleName = nameValue[0];
            var sStyleValue = nameValue[1];

            var oStyle = {};
            oStyle.styleName = sStyleName;
            oStyle.styleValue = sStyleValue;
            styleObjArray.push(oStyle);
        }
        return styleObjArray;
    };

    /**
     * Creates a new &lt;body .../&gt; element which is the container for XFA Rich Text.
     * @return The new &lt;body .../&gt; element as an XML object.
     */
    XfaRichTextUtil.createBodyElement = function () {
        // XHTML is the default namespace -- make sure you specify an empty string prefix otherwise later code that calls namespaceDeclarations()
        //  on this node will not see the default namespace!
        var nsXhtml = new Namespace("", XfaXhtml.XHTMLNSURI);
        var nsXfa = new Namespace(XfaSchema.XFANS, XfaData.XFADATANSURI);

        var xfaBody = ns.XmlUtil.createTag(XfaXhtml.BODY);
        xfaBody.setNamespace(nsXhtml);
        xfaBody.addNamespace(nsXfa);
        var attribute = new AttributeName(QName(nsXfa, "xfa:APIVersion"));
        xfaBody.Put("@xfa:APIVersion", XfaXhtml.AXTEAPIVERSION);

        return xfaBody;
    };

})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var PlainTextFormatter = ns.PlainTextFormatter = function () {

        this.error = null;
    };

    PlainTextFormatter.prototype.format = function (value) {
        if (this.error) {
            this.error = null;
        }

        if (!value || String(value).length == 0) {
            this.error = "Invalid value";
            return "";
        }
        return this.formatAsPlain(value);
    };

    PlainTextFormatter.prototype.formatAsPlain = function (value) {
        var inputText;

        if (value instanceof XML) {
            // assume this could be XFA and be careful with whitespace
            inputText = ns.XfaUtil.print(value);
        } else if (typeof value == "string") {
            // could be XFA Rich Text XML in string format or could be plain text
            inputText = value;
        } else {
            this.error = "Invalid type";
            return "";
        }

        if (ns.XfaRichTextUtil.isPlainText(inputText)) {
            // value is already formatted as plain text
            return inputText;
        }

        if (ns.XfaRichTextUtil.isXfaRichText(inputText)) {
            var xfaNode = ns.XfaUtil.load(inputText);
            var xfaPlainText = {};
            this.formatXfaPlainText(xfaNode, xfaPlainText);

            if (xfaPlainText.hasOwnProperty("error")) {
                this.error = xfaPlainText.error;
                return "";
            } else {
                return xfaPlainText.text;
            }
        }
        this.error = "Invalid value";
        return "";
    };
    /**
     * Takes a node representing XFA XHTML markup and converts it into plain text without any formating.
     * @param xfaNode [in] XML node representing XFA rich text markup.
     * @param result [out] Dynamic object which, upon return, has a "text" property containing the plain text string and,
     *  if an error occurred, an "error" property containing the error message.
     */
    PlainTextFormatter.prototype.formatXfaPlainText = function (xfaNode, result) {
        if (!xfaNode) {
            result.error = "Invalid XFA rich text markup";
            return;
        }

        var childXml, childList = xfaNode.children();

        for (var index = 0;
             index < childList.length();
             index++) {
            childXml = childList[index];
            if (childXml.nodeKind() == ns.XmlUtil.NODEKIND_ELEMENT) {
                var lookInside = true;
                var className = childXml.localName();

                switch (className.toUpperCase()) {
                    case "P":
                        this.convertParaTag(result);
                        break;

                    case "BR":
                        this.convertBreakTag(result);
                        break;

                    default:
                        break;
                }

                // make sure the conversions are OK
                if (result.hasOwnProperty("error")) {
                    return;
                }

                if (lookInside) {
                    this.formatXfaPlainText(childXml, result);
                    if (result.hasOwnProperty("error")) {
                        return;
                    }
                }
            } else if (childXml.nodeKind() == ns.XmlUtil.NODEKIND_TEXT) {
                if (result.hasOwnProperty("text")) {
                    result.text += ns.XmlUtil.getNodeText(childXml);
                } else {
                    result.text = ns.XmlUtil.getNodeText(childXml);
                }
            }
            // else, ignore attributes, PIs and comments
        }
    };

    /** Converts a &lt;p&gt; tag to plain text. Appends the result to the result object's "text" property. */
    PlainTextFormatter.prototype.convertParaTag = function (result) {
        // if it's not the very first paragraph, a paragraph equals two new lines
        if (result.hasOwnProperty("text")) {
            result.text += "\n\n";
        }
    };

    /** Converts a &lt;br&gt; tag to plain text. Appends the result to the result object's "text" property. */
    PlainTextFormatter.prototype.convertBreakTag = function (result) {
        // a line break is always equal to a single new line
        var newLine = "\n";

        if (result.hasOwnProperty("text")) {
            result.text += newLine;
        } else {
            result.text = newLine;
        }
    };
})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var HtmlUtils = ns.HtmlUtils = function () {
    };

    HtmlUtils.calculateHtmlPosition = function (htmlstr, pos) {
        // we return -1 (not found) if the position is bad
        if (pos <= -1) {
            return -1;
        }

        // characters that appears when a tag starts
        var openTags = ["<", "&"];
        // characters that appears when a tag ends
        var closeTags = [">", ";"];
        // the tag should be replaced with
        // ex: &amp; is & and has 1 as length but normal
        // tags have 0 length
        var tagReplaceLength = [0, 1];
        // flag to know when we are inside a tag
        var isInsideTag = false;
        var cnt = 0;
        // the id of the tag opening found
        var tagId = -1;
        var tagContent = "";

        for (var i = 0; i < htmlstr.length; i++) {
            // if the counter passes the position specified
            // means that we reach the text position
            if (cnt >= pos) {
                break;
            }
            // current char
            var currentChar = htmlstr.charAt(i);
            // checking if the current char is in the open tag array
            for (var j = 0; j < openTags.length; j++) {
                if (currentChar == openTags[j]) {
                    // set flag
                    isInsideTag = true;
                    // store the tag open id
                    tagId = j;
                }
            }
            if (!isInsideTag) {
                // increment the counter
                cnt++;
            } else {
                // store the tag content
                // needed afterwards to find new lines
                tagContent += currentChar;
            }
            if (currentChar == closeTags[tagId]) {
                // we ad the replace length
                if (tagId > -1) {
                    cnt += tagReplaceLength[tagId];
                }
                // if we encounter the </P> tag we increment the counter
                // because of new line character
                if (tagContent == "</P>") {
                    cnt++;
                }
                // set flag
                isInsideTag = false;
                // reset tag content
                tagContent = "";
            }
        }
        // return the position in html text
        return i;
    };

    /**
     * Given TLF Html Text, which means the string has the format <code>&lt;html&gt;&lt;body ...&gt;{HTML}&lt;/body&gt;&lt;/html&gt;</code>, remove
     *  the <code>&lt;html&gt;&lt;body&gt;</code> root element and return the content.
     * @param tlfHtml TLF exported Html.
     * @return The XHTML content of the TLF Text. If the provided string wasn't wrapped in the body element, the original
     *  string is returned.
     */
    HtmlUtils.extractXhtmlContent = function (tlfHtml) {
        if (!tlfHtml) {
            return tlfHtml;
        } // null or empty string

        var RegExpr = XRegExp('^<HTML><BODY[^>]*>\\s*(.*)\\s*<\/BODY><\/HTML>', "gis");
        var result = RegExpr.exec(tlfHtml);
        if (result) {
            return result[1];
        }

        return tlfHtml;
    };
    HtmlUtils.searchBackwards = function (source, searchText, indexPosition) {
        for (var i = indexPosition; i >= 0; i--) {
            var index = source.indexOf(searchText, i);
            if (index == i) {
                return i;
            }
        }
        return -1;
    };

    HtmlUtils.searchForward = function (source, searchText, indexPosition) {
        for (var i = indexPosition; i < source.length; i++) {
            var index = source.indexOf(searchText, i);
            if (index == i) {
                return i;
            }
        }
        return -1;
    };

    /**
     * Converts HTML to XFA XHTML.
     * @param str HTML text to convert.
     * @return XFA XHTML equivalent as a <code>String</code>. Note that while the string contains XML, it will be a series of elements without
     *  a root node which means it should be wrapped in a root node in order to load it as valid XML.
     */

    HtmlUtils.richTextEditorToHtml = function (str, config) {
        var xmlSettings = XML.settings();
        XML.prettyPrinting = false;
        XML.ignoreWhitespace = false;

        //Remove the "<html><body>" wrapper tags that might have been introduced due to TLF exported html.
        str = HtmlUtils.extractXhtmlContent(str);

        // Code to convert <br> </br> to <br/> as otherwise it gets converted to <br> <br> by innerHTML
        var pattern = new RegExp('<br><\/br>', 'gi');
        str = str.replace(pattern, "<br/>");

        // Create XML document
        var XMLObj = document.createElement("BODY");
        XMLObj.innerHTML = str;
        // temporary
        var t1;
        var t2;
        // remove the TABSTOPS Attribute
        //var elements = $(xmlObj);
        $(XMLObj).find('*').removeAttr('TABSTOPS');

        // remove the TARGET Attribute Except for Anchor tag
        //var elements = $(xmlObj);
        $(XMLObj).find('*').not("a").removeAttr('TARGET');

        // Find the TEXTFORMAT LEADING Attribute
        $(XMLObj).find('*[LEADING]').each(function () {
            var t2 = $(this);
            var leading = parseFloat(t2.attr("leading"));
            var t3;
            var t4;
            var t5;
            $(t2).find('P').each(function () {
                t4 = $(this);
                var size = parseFloat(leading);
                $(t4).find('FONT').each(function () {
                    t5 = $(this);
                    if (t5 != null && t5.length > 0) {
                        var fontSize = parseFloat(t5.attr("SIZE"));
                        if ((fontSize + leading) > size) {
                            size = fontSize + leading;
                        }
                    }
                });
                var style1 = $(t4).attr("style");
                if (style1 != undefined) {
                    //removing the old line-height if exists to update with new line-height
                    //as currently new line-height is appended to style but not honoured because of old line-height still present
                    var reg = /(line-height:.*?pt;)/gi;
                    style1 = style1.replace(reg, "");
                }
                $(t4).attr('style', 'line-height:' + size + 'pt;' + ((typeof style1 == 'undefined') ? '' : style1));
            });
            $(t2).removeAttr('LEADING');
        });

        // Find all LEFTMARGIN in TEXTFORMAT
        $(XMLObj).find('*[LEFTMARGIN]').each(function () {
            var t2 = $(this);
            var leftMargin = parseFloat(t2.attr('LEFTMARGIN'));
            $(t2).find('P').each(function () {
                var t4 = (this);
                var style = t4.attr('style');
                t4.attr('style', 'margin-left: ' + leftMargin + 'pt;' + ((typeof style == 'undefined') ? '' : style));
            });
            $(t2).removeAttr('LEFTMARGIN');
        });

        // Find all INDENT in TEXTFORMAt
        $(XMLObj).find('*[INDENT]').each(function () {
            var t2 = $(this);
            var indent = parseFloat(t2.attr('INDENT'));
            $(t2).find('P').each(function () {
                var t4 = $(this);
                var style = t4.attr('style');
                //  alert("style1 indent"+style);
                t4.attr('style', 'text-indent: ' + indent + 'pt;' + ((typeof style == 'undefined') ? '' : style));
                //alert($(t4).attr('style'));
            });
            $(t2).removeAttr('INDENT');
        });

        // Find all ALIGN
        $(XMLObj).find('*[ALIGN]').each(function () {
            var t2 = $(this);
            var align = t2.attr('ALIGN');
            var style = t2.attr('style');
            //alert("style1 align"+style);
            t2.attr('style', 'text-align: ' + align + ';' + ((typeof style == 'undefined') ? '' : style));
            //alert($(t2).attr('style'));
            $(t2).removeAttr('ALIGN');
        });

        // Find all FACE
        $(XMLObj).find('*[FACE]').each(function () {
            var t2 = $(this);
            var face = t2.attr('FACE');
            var style = t2.attr('style');
            //  alert("style1 face"+style);
            t2.attr('style', 'font-family: ' + face + ';' + ((typeof style == 'undefined') ? '' : style));
            //	alert($(t2).attr('style'));
            $(t2).removeAttr('FACE');
        });
        // Find all SIZE
        $(XMLObj).find('*[SIZE]').each(function () {
            var t2 = $(this);
            var size = parseFloat(t2.attr('SIZE'));
            var style = t2.attr('style');
            //alert("style1 size"+style);
            t2.attr('style', 'font-size: ' + size + 'pt;' + ((typeof style == 'undefined') ? '' : style));
            //alert($(t2).attr('style'));
            $(t2).removeAttr('SIZE');
        });

        // Find all COLOR
        $(XMLObj).find('*[COLOR]').each(function () {
            var t2 = $(this);
            var color = t2.attr('COLOR');
            var style = t2.attr('style');
            //alert("style1 color "+style);
            t2.attr('style', 'color: ' + color + ';' + ((typeof style == 'undefined') ? '' : style));
            //alert($(t2).attr('style'));
            $(t2).removeAttr('COLOR');
        });
        // Find all LETTERSPACING
        $(XMLObj).find('*[LETTERSPACING]').each(function () {
            var t2 = $(this);
            var letterSpacing = t2.attr('LETTERSPACING');
            var style = t2.attr('style');
            //alert("style1 letterSpacing "+style);
            t2.attr('style', 'letter-spacing: ' + letterSpacing + 'pt;' + ((typeof style == 'undefined') ? '' : style));
            //alert($(t2).attr('style'));
            $(t2).removeAttr('LETTERSPACING');
        });
        // Find all KERNING
        $(XMLObj).find('*[KERNING]').each(function () {
            var t2 = $(this);

            $(t2).removeAttr('KERNING');
        });

        var cleanHtml = this.cleanHTML(XMLObj.innerHTML, config);

        XML.setSettings(xmlSettings); // restore original settings
        return cleanHtml;
    };
    HtmlUtils.wrapInBody = function (html) {
        if (html.match(/<body[^>]*>[\s\S]*<\/body>/gi) == null) {
            html = '<body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/" xfa:APIVersion="2.7.0.0">' + html + '</body>';
        }
        return html;
    };

    /**
     * Given a string with the format <body ...>{XHTML}</body>, remove the <body> root element and surrounding whitespace and return the content
     * @param html
     */
    HtmlUtils.extractBodyContent = function (html) {
        if (!html) {
            return "";
        }
        // given a string with the format <body ...>{XHTML}</body>, remove the <body> root element and surrounding whitespace and return the content
        var re = XRegExp("^\\s*<body[^>]*>\\s*(.*)\\s*<\/body>\\s*$", "gs");
        var result = re.exec(html); // will return null if the body node is <body .../>

        var content = "";
        if (result != null && result.length > 1) {
            content = result[1];
        }

        return content;
    };

    /**
     * Formats the Rich Text and adds all content inside <p><span></span></p>
     * @param str
     * @returns returns the formatted string
     */
    HtmlUtils.cleanRichText = function (str, config) {

        //Replace Div's with para tag
        var pattern = new RegExp('<div', 'gi');
        str = str.replace(pattern, '<p');

        pattern = new RegExp('</div>', 'gi');
        str = str.replace(pattern, '</p>');

        //Move all outside content after </p> inside p > span
        pattern = new RegExp('\/p>([^<]+|<br></br>)(<p|[^<]*$)', 'gi');
        str = str.replace(pattern, "\/p><p><span>$1</span><\/p>$2");

        //Move all outside content before <p> inside p > span
        pattern = new RegExp('(^[^<]+|<br></br>)(<p|[^<]*$)', 'i');
        str = str.replace(pattern, "<p><span>$1</span><\/p>$2");

        //Move para content without any span within span
        pattern = new RegExp('(<p[^<]*>)(((?!((<span)|(<\/p>))).)*)<\/p>','gi');
        str = str.replace(pattern, "$1<span>$2<\/span><\/p>");

        // empty lines will get lost if they don't contain at least one space
        // an empty line will may look like <p ...><span ...><span ...></span ...></span ...></p> so replace it with <p ...><span ...><span ...></span ...></span ...></p>
        //(at least one span should have single space as content)
        //  so that when we add 'xfa-spacerun:yes' to all span styles (later), the space is retained and the Adobe Text Engine renders the empty line

        pattern = new RegExp('<p([^>]*)>(.*?)<\/p>', 'gi');
        str = str.replace(pattern, HtmlUtils.convertEmptyParaToXhtml);

        //Remove Empty Para
        pattern = new RegExp('<p([^>]*)><\/p>', 'gi');
        str = str.replace(pattern, '');

        //Add default styles to li already containing style attribute
        pattern = new RegExp('<li([^<]*) style="([^<"]*)"([^<]*)>', 'gi');
        var result = pattern.exec(str);
        while (result && result.length > 3) {
            str = str.replace(result[0], '<li' + result[1] + ' style="' + HtmlUtils.getMissingParaStyle(result[2], config) + '"' + result[3] + '>');
            result = pattern.exec(str);
        }

        //Add default style to li
        pattern = new RegExp('<li(((?!style=")[^>])*)>', 'gi');
        str = str.replace(pattern, '<li style="' + HtmlUtils.getDefaultParaStyle(config) + '">');

        //Replacing all para inside li to temp tag to avoid default style to be added.
        pattern = new RegExp('<li([^>]*)>([^<]*)<p([^>]*)>(((?!<p).)*)</p>', 'gi');
        str = str.replace(pattern, '<li$1>$2<temp$3>$4</temp>');

        //Add default styles to para already containing style attribute
        pattern = new RegExp('<p([^<]*) style="([^<"]*)"([^<]*)>', 'gi');
        var result = pattern.exec(str);
        while (result && result.length > 3) {
            str = str.replace(result[0], '<p' + result[1] + ' style="' + HtmlUtils.getMissingParaStyle(result[2], config) + '"' + result[3] + '>');
            result = pattern.exec(str);
        }

        //Add default style to para
        pattern = new RegExp('<p(((?!style=")[^>])*)>', 'gi');
        str = str.replace(pattern, '<p style="' + HtmlUtils.getDefaultParaStyle(config) + '">');

        //Changing temp tag back to para
        pattern = new RegExp('<temp([^>]*)>(((?!<temp).)*)</temp>', 'gi');
        str = str.replace(pattern, '<p$1>$2</p>');

        return str;
    };

    /**
     * Cleans an already somewhat formatted XHTML string converted from HTML.
     * @param str Partially-converted XFA XHTML content from HTML source. The string is expected to contain multiple
     *  elements without a root node.
     * @return XFA XHTML content, fully-converted, containing multiple elements without a root node.
     */
    HtmlUtils.cleanHTML = function (str, config) {

        if (str == "") {
            return str;
        }

        //TODO: Why we need to replace these. Then we should correct the regex
        /* replace all empty lines that are formatted with bullet style
         var pattern:RegExp = /(<TEXTFORMAT.*?>)?<LI><FONT\s[^>]*?\/?>(<(B|I|U)>)*?(<\/(B|I|U)>)*?(<\/FONT>)?<\/LI>(<\/TEXTFORMAT>)?/ig;
         var str:String = string.replace(pattern, "<p/>"); */
        // format <indent> tag

        var pattern = new RegExp('TEXTFORMAT', "gi");

        str = str.replace(pattern, "SPAN");
        pattern = new RegExp('COLOR=\"(.*?)\"', 'gi');

        str = str.replace(pattern, "color:$1;");
        pattern = new RegExp('SIZE=\"(.*?)\"', 'gi');

        str = str.replace(pattern, "font-size:$1pt;");
        pattern = new RegExp('FACE="(.*?)\"/', 'gi');

        str = str.replace(pattern, "font-family:$1;");
        pattern = new RegExp('ALIGN=\"(.*?)\"', 'gi');

        str = str.replace(pattern, "text-align:$1;");

        // format <indent> tag
        pattern = new RegExp('INDENT=\"(.*?)\"', 'gi');
        str = str.replace(pattern, "text-indent:$1;");

        //format <font> tag
        pattern = new RegExp('<FONT STYLE', 'gi');
        str = str.replace(pattern, "<span style");

        pattern = new RegExp('<FONT>', 'gi');
        str = str.replace(pattern, "<span>");

        pattern = new RegExp('<\/FONT>', 'gi');
        str = str.replace(pattern, "<\/span>");

        //LK: replace empty <FONT/> tags
        pattern = new RegExp('<FONT\/>', 'gi');
        str = str.replace(pattern, "");

        //format <p> tag
        pattern = new RegExp('<P STYLE', 'gi');
        str = str.replace(pattern, "<p style");

        pattern = new RegExp('<\/P>', 'gi');
        str = str.replace(pattern, "<\/p>");

        //format <a> tag
        pattern = new RegExp('<A HREF', 'gi');
        str = str.replace(pattern, "<a href");

        pattern = new RegExp('<\/A>', 'gi');
        str = str.replace(pattern, "<\/a>");

        //format <span> tag
        pattern = new RegExp('<SPAN STYLE', 'gi');
        str = str.replace(pattern, "<span style");

        pattern = new RegExp('<SPAN', 'gi');
        str = str.replace(pattern, "<span");

        pattern = new RegExp('<\/SPAN>', 'gi');
        str = str.replace(pattern, "<\/span>");

        var pattern = new RegExp('<br>(?!<\/br>)', 'gi');
        str = str.replace(pattern, "<br><\/br>");

        // remove any bullets we might find since we don't support bulleting in a text module
        // pattern = /<LI>/gi;
        // var bulletFormat:String = "<p>";
        // str = str.replace(pattern, bulletFormat);
        // pattern= /<\/LI>/gi;
        // str = str.replace(pattern, "</p>");

        //TODO: count connected \t occurrences and add only one span tag with the right tab-count property
        //replace all \t escape characters with \t and xfa tab since \t is not honoured while previewing letter in CCR
        // and xfa tab is not honoured in HTML text editor.
        pattern = new RegExp('\t(?!(<span style="xfa-tab-count:1"><\/span>))', 'g');
        str = str.replace(pattern, "\t<span style=\"xfa-tab-count:1\"></span>");

        //do Variable replacement
        pattern = new RegExp('(\{\$(.*?)\$\})', 'gi');
        str = str.replace(pattern, "<span xfa:embedType=\"uri\" xfa:embedMode=\"raw\" xfa:embed=\"$2\">$1</span>");

        // format <ul> tag -- we don't support lists, so remove these tags since each list item we may have found will now be its own paragraph
        // pattern= /<UL>/gi;
        // str = str.replace(pattern, "");
        // pattern= /<\/UL>/gi;
        // str = str.replace(pattern, "");
        // format <ol> tag -- we don't support lists, so remove these tags since each list item we may have found will now be its own paragraph
        // pattern= /<OL>/gi;
        // str = str.replace(pattern, "");
        // pattern= /<\/OL>/gi;
        // str = str.replace(pattern, "");

        //format alignment in styles tag
        pattern = new RegExp('text-align: RIGHT', 'gi');
        str = str.replace(pattern, "text-align: right");

        pattern = new RegExp('text-align: LEFT', 'gi');
        str = str.replace(pattern, "text-align: left");

        pattern = new RegExp('text-align: CENTER', 'gi');
        str = str.replace(pattern, "text-align: center");

        pattern = new RegExp('text-align: JUSTIFY', 'gi');
        str = str.replace(pattern, "text-align: justify");

        //this is to fix a bug
        //for some reason there is a U/B/I/ tag showing up?

        pattern = new RegExp('<U\/>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<U><\/U>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<U><br></U>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<U><br><\/br></U>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<B\/>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<B><\/B>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<B><br></B>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<B><br><\/br></B>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<I\/>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<I><\/I>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<I><br></I>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<I><br><\/br></I>', 'gi');
        str = str.replace(pattern, "<br></br>");

        //LK: p in span should not happen...
        pattern = new RegExp('<span>\s*<p ', 'gi');
        str = str.replace(pattern, "<p ");

        pattern = new RegExp('<\/p>\s*<\/span>', 'gi');
        str = str.replace(pattern, "</p>");

        //LK avoid blanks at beginning of lines
        // we need to assemble span tags
        //pattern = /<span style="([^"]*)">[^<]*<span style="([^"]*)">([^<]*)<\/span>\s*<\/span>/gi;
        //SST 09.05.08 : Assemble span tags in case there is no other text between the span tags

        pattern = new RegExp('<span style="([^"]*)"><span style="([^"]*)">([^<]*)<\/span>\s*<\/span>', 'gi');
        str = str.replace(pattern, HtmlUtils.mergeXhtmlSpanStyles);
        str = str.replace(pattern, HtmlUtils.mergeXhtmlSpanStyles);
        str = str.replace(pattern, HtmlUtils.mergeXhtmlSpanStyles);

        // Replace multiple spaces with &#160;
        pattern = new RegExp('  ', 'g');
        str = str.replace(pattern, "&#160;&#160;");

        // replacing all &nbsp; to &#160;
        pattern = new RegExp('&nbsp;', 'g');
        str = str.replace(pattern, "&#160;");

        str = HtmlUtils.cleanRichText(str, config);

        //next all spans with xfa-spacerun:yes:
        //pattern = new RegExp('<span style="([^"]*)">','gi');
        //str = str.replace(pattern, "<span style=\"$1; xfa-spacerun:yes\">");
        //Spaces between the tags will get lost if they don't own Spans
        //Moving tabs/white-spaces outside html tags inside span tag
        pattern = new RegExp('>([ \t]+)<?!(\/)', 'gi');
        str = str.replace(pattern, "><span style=\"xfa-spacerun:yes\">$1</span><");

        //LK: Formatting of variables must be chosen, otherwise it will be lost when replacing
        //    the variables by its value
        pattern = new RegExp('<span xfa:embedType="uri" xfa:embedMode="raw" xfa:embed="([^"]*)">\s*<span style=([^>]*)>([^<]*)<\/span>\s*<\/span>', 'gi');
        str = str.replace(pattern, "<span style=$2><span xfa:embedType=\"uri\" xfa:embedMode=\"raw\" xfa:embed=\"$1\">$3</span></span>");

        return str;
    };

    /**
     * This function is used as replacement function to assemble span tags in case there is no other text between the span tags
     * pattern = /<span style="([^"]*)">[^<]*<span style="([^"]*)">([^<]*)<\/span>\s*<\/span>/gi;
     * param arguments
     * @return
     *
     */
    HtmlUtils.mergeXhtmlSpanStyles = function () {

        //There should be three groups in matched strings: outer span styles, inner span styles, inner span contents. If that's not the case, return the original string

        if (arguments.length != 6) {
            return arguments[0];
        }

        var outerStylesStr = arguments[1];
        var innerStyles = arguments[2];
        var spanContent = arguments[3];

        var margedStyles = (innerStyles != null) ? innerStyles : "";
        var outerStyles = outerStylesStr.split(";");

        for (var i = 0; i < outerStyles.length; i++) {
            var outerStyle = outerStyles[i];
            if (outerStyle.indexOf(":") > 0) {
                var styleName = outerStyle.substring(0, outerStyle.indexOf(":"));
                styleName = styleName.trim();
                if (margedStyles.toLowerCase().indexOf(styleName.toLowerCase()) < 0) {
                    margedStyles = margedStyles + "; " + outerStyle.trim();
                }
            }
        }
        return "<span style=\"" + margedStyles + "\">" + spanContent + "</span>";
    };

    /**
     * Handles the paragraph that does not have any content to insert a empty space so that can be used with space run
     * to show new lines in xfa for empty para.
     * Note: this does not explicitly adds xfa-spacerun to span tags
     * param arguments
     * @return
     */

    HtmlUtils.convertEmptyParaToXhtml = function () {
        var str = String(arguments[0]);
        var plainTextFormatter = new ns.PlainTextFormatter();
        var plainText = plainTextFormatter.format(str);
        //if(!(plainText) && !(error)){
        if (!(plainText)) {
            var str1 = str;
            //Handle both expanded and non expanded span.

            var pattern = new RegExp('<span([^>]*)\/>', 'i');
            str = str.replace(pattern, "<span$1> </span>");

            pattern = new RegExp('<span([^>]*)\><\/span>', 'i');
            str = str.replace(pattern, "<span$1> </span>");

            pattern = new RegExp('<span([^>]*)>[\s ]*</span>', 'i');
            str = str.replace(pattern, "<span$1><br></br></span>");

        }

        return str;
    };

    HtmlUtils.getDefaultParaStyle = function (config) {
        var style = "";
        if (config) {
            style += 'font-family:' + config.fontFamily.defaultValue + ';';
            style += 'font-size:' + config.fontSize.defaultValue + 'pt;';
            style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'pt;';
            style += 'color:#000000;';
            style += 'text-align:left;';
        }

        return style;
    };

    HtmlUtils.getMissingParaStyle = function (style, config) {
        if (style && style.length > 0) {
            if (config) {
                if (!ns.StringHelper.endsWith(style, ";")) {
                    style += ";";
                }
                if (style.indexOf("font-family") < 0) {
                    style += 'font-family:' + config.fontFamily.defaultValue + ';';
                }
                if (style.indexOf("font-size") < 0) {
                    style += 'font-size:' + config.fontSize.defaultValue + 'pt;';
                }
                if (style.indexOf("letter-spacing") < 0) {
                    style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'pt;';
                }
                if (style.indexOf("color") < 0) {
                    style += 'color:#000000;';
                }
                if (style.indexOf("text-align") < 0) {
                    style += 'text-align:left;';
                }
            }
        } else {
            style = HtmlUtils.getDefaultParaStyle(config);
        }
        return style;
    };

})(Form.rte.util);

(function () {
// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/button.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1, helper;

  return "<button class=\"rte-button rte-button-quiet "
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + " "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + " "
    + ((stack1 = helpers["if"].call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.selected : depth0),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "")
    + "\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-statecallbackfn=\"Form.rte.CommandStateCallbacks.setButtonState\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" type=\"button\" name=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-value=\""
    + container.escapeExpression(((helper = (helper = helpers.value || (depth0 != null ? depth0.value : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"value","hash":{},"data":data}) : helper)))
    + "\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\" href=\"javascript:;\" unselectable=\"on\">\n    <span class=\"icon-"
    + container.escapeExpression(((helper = (helper = helpers.icon || (depth0 != null ? depth0.icon : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"icon","hash":{},"data":data}) : helper)))
    + "\" aria-hidden=\"true\"></span>\n    "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.text : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\n</button>";
},"1":function(container,depth0,helpers,partials,data) {
    return "active";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['button'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['button'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/colorInput.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var helper;

  return "<div class=\"rte-colorInput "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\">\n    <span>"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.label : depth0),{"name":"I18n","hash":{},"data":data}))
    + "</span>\n    <input class=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + " rte-colorInput-control\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-stateCallbackFn=\"Form.rte.CommandStateCallbacks.setColorInputValue\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-skip>\n</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['colorInput'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['colorInput'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/findAndReplace.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    return "<form class=\"rte_findAndReplace_dialog\">\n    <input name=\"findText\" type=\"text\" placeholder=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Find",{"name":"I18n","hash":{},"data":data}))
    + "\" class=\"rte-input\" data-wysihtml5-command=\"changeFindText\" data-wysihtml5-skip>\n    <input name=\"replaceText\" type=\"text\" placeholder=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Replace",{"name":"I18n","hash":{},"data":data}))
    + "\" class=\"rte-input\" data-wysihtml5-command=\"changeReplaceText\" data-wysihtml5-skip>\n    <div class=\"rte-block-group\">\n        <label>\n            <input name=\"matchCase\" type=\"checkbox\" class=\"rte_matchCase\" data-wysihtml5-command=\"changeMatchCase\" data-wysihtml5-skip>\n            "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Match case",{"name":"I18n","hash":{},"data":data}))
    + "\n        </label>\n        <label>\n            <input name=\"wholeWord\" type=\"checkbox\" class=\"rte_wholeWord\" data-wysihtml5-command=\"changeWholeWord\" data-wysihtml5-skip>\n            "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Whole word",{"name":"I18n","hash":{},"data":data}))
    + "\n        </label>\n        <label>\n            <input name=\"regExp\" onchange=\"this.form.wholeWord.disabled = this.checked\" type=\"checkbox\" class=\"rte_regExp\" data-wysihtml5-command=\"changeRegExp\" data-wysihtml5-skip>\n            "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Reg Ex",{"name":"I18n","hash":{},"data":data}))
    + "\n        </label>\n    </div>\n    <div class=\"rte-block-group\">\n    <button data-wysihtml5-command=\"find\" class=\"rte-button\" tabindex=\"-1\" type=\"button\">"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Find",{"name":"I18n","hash":{},"data":data}))
    + "</button>\n    <button tabindex=\"-1\" data-wysihtml5-command=\"replace\" class=\"rte-button\" type=\"button\">"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Replace",{"name":"I18n","hash":{},"data":data}))
    + "</button>\n    <button data-wysihtml5-command=\"replaceAll\" class=\"rte-button\" tabindex=\"-1\" type=\"button\">"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Replace all",{"name":"I18n","hash":{},"data":data}))
    + "</button>\n    </div>\n    <div class=\"rte_findNReplace_alert alert alert-info alert-dismissable\">\n        <button type=\"button\" class=\"close\" data-dismiss=\"alert\" aria-hidden=\"true\">\n            &times;\n        </button>\n        <strong>"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Info",{"name":"I18n","hash":{},"data":data}))
    + "</strong>\n        <span class=\"rte_findNReplace_message\"></span>\n    </div>\n</form>\n";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['findAndReplace'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['findAndReplace'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/group.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1, helper;

  return "<div class=\"rte-group "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" role=\"group\">\n"
    + ((stack1 = ((helper = (helper = helpers.content || (depth0 != null ? depth0.content : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"content","hash":{},"data":data}) : helper))) != null ? stack1 : "")
    + "\n</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['group'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['group'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/link.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    return "<form class=\"rte_insertLink_dialog\" role=\"form\">\n    <input type=\"text\" placeholder=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"URL",{"name":"I18n","hash":{},"data":data}))
    + "\" class=\"rte-input\" name=\"url\">\n    <input type=\"text\" placeholder=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Alt Text",{"name":"I18n","hash":{},"data":data}))
    + "\" value=\"\" name=\"alt\" class=\"rte-input\">\n    <span>\n        <input type=\"checkbox\" name=\"target\" value=\"false\">\n        "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Open in new page",{"name":"I18n","hash":{},"data":data}))
    + "\n    </span>\n    <button name=\"submit\" tabindex=\"-1\" class=\"rte-button rte-button-square\" type=\"button\" data-wysihtml5-command=\"createLink\" rte-close>\n        <span class=\"icon-ok\"></span>\n    </button>\n    <button tabindex=\"-1\" class=\"rte-button rte-button-square\" type=\"button\" rte-close>\n        <span class=\"icon-cancel\"></span>\n    </button>\n</form>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['link'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['link'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/numberInput.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var helper;

  return "<div class=\"rte-numberInput "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\">\n    <span>"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.label : depth0),{"name":"I18n","hash":{},"data":data}))
    + "</span>\n    <input class=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" value=\"0\" name=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" type=\"number\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-stateCallbackFn=\"Form.rte.CommandStateCallbacks.setNumberInputValue\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" unselectable=\"off\" data-wysihtml5-skip min=\"0\" step=\"any\">\n</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['numberInput'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['numberInput'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/popover.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1, helper;

  return "<div class=\"rte-popover\">\n    <button class=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + " rte-button rte-button-quiet "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" type=\"button\" data-placement=\""
    + container.escapeExpression(((helper = (helper = helpers.placement || (depth0 != null ? depth0.placement : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"placement","hash":{},"data":data}) : helper)))
    + "\" name=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-statecallbackfn=\""
    + container.escapeExpression(((helper = (helper = helpers.callback || (depth0 != null ? depth0.callback : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"callback","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" href=\"javascript:;\" unselectable=\"on\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\">\n        <span class=\"icon-"
    + container.escapeExpression(((helper = (helper = helpers.icon || (depth0 != null ? depth0.icon : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"icon","hash":{},"data":data}) : helper)))
    + "\" aria-hidden=\"true\"></span>\n        "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.text : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\n    </button>\n    <div class=\"popover\">"
    + ((stack1 = ((helper = (helper = helpers.content || (depth0 != null ? depth0.content : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"content","hash":{},"data":data}) : helper))) != null ? stack1 : "")
    + "</div>\n</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['popover'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['popover'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/rtetoolbar.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1;

  return "<div class=\"rte_toolBar\" role=\"toolbar\">"
    + ((stack1 = container.lambda(depth0, depth0)) != null ? stack1 : "")
    + "</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['rtetoolbar'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['rtetoolbar'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/select.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1, helper;

  return "<div class=\"rte-select\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\">\n    <select class=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + " "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-skip=\"\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-stateCallbackFn=\"Form.rte.CommandStateCallbacks.setSelectState\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\">\n        <option value=\"\" style=\"display:none\">"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Select",{"name":"I18n","hash":{},"data":data}))
    + "</option>\n"
    + ((stack1 = helpers.each.call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.options : depth0),{"name":"each","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "")
    + "    </select>\n    <i class=\"rte-toggleSelect icon-down-open\"></i>\n</div>\n";
},"1":function(container,depth0,helpers,partials,data) {
    var stack1;

  return "               <option value=\""
    + ((stack1 = helpers["if"].call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.value : depth0),{"name":"if","hash":{},"fn":container.program(2, data, 0),"inverse":container.program(4, data, 0),"data":data})) != null ? stack1 : "")
    + "\">"
    + ((stack1 = helpers["if"].call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.label : depth0),{"name":"if","hash":{},"fn":container.program(6, data, 0),"inverse":container.program(8, data, 0),"data":data})) != null ? stack1 : "")
    + "</option>\n";
},"2":function(container,depth0,helpers,partials,data) {
    var helper;

  return container.escapeExpression(((helper = (helper = helpers.value || (depth0 != null ? depth0.value : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"value","hash":{},"data":data}) : helper)));
},"4":function(container,depth0,helpers,partials,data) {
    return container.escapeExpression(container.lambda(depth0, depth0));
},"6":function(container,depth0,helpers,partials,data) {
    return container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.label : depth0),{"name":"I18n","hash":{},"data":data}));
},"8":function(container,depth0,helpers,partials,data) {
    return container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},depth0,{"name":"I18n","hash":{},"data":data}));
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['select'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['select'] = template;



})();
/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/29/2016.
 */

(function (ns) {

    /* Out of the box provided Commands*/
    var Commands = ns.Commands = {};

    Commands.UNDO = "undo";
    Commands.REDO = "redo";

    Commands.BOLD = "bold";
    Commands.ITALIC = "italic";
    Commands.UNDERLINE = "underline";
    Commands.SUPERSCRIPT = "superscript";
    Commands.SUBSCRIPT = "subscript";
    Commands.FORE_COLOR = "foreColor";
    Commands.HILITE_COLOR = "hiliteColor";

    Commands.FONT_FAMILY = "fontFamily";
    Commands.FONT_SIZE = "fontSize";
    Commands.LINE_HEIGHT = "lineHeight";
    Commands.LETTER_SPACING = "letterSpacing";
    Commands.HEADER = "header";

    Commands.JUSTIFY_LEFT = "justifyLeft";
    Commands.JUSTIFY_CENTER = "justifyCenter";
    Commands.JUSTIFY_FULL = "justifyFull";
    Commands.JUSTIFY_RIGHT = "justifyRight";

    Commands.MARGIN_LEFT = "marginLeft";
    Commands.MARGIN_RIGHT = "marginRight";
    Commands.MARGIN_TOP = "marginTop";
    Commands.MARGIN_BOTTOM = "marginBottom";

    Commands.INSERT_UNORDERED_LIST = "insertUnorderedList";
    Commands.INSERT_ORDERED_LIST = "insertOrderedList";
    Commands.INSERT_UPPERCASE_ALPHABET_LIST = "insertUppercaseAlphabetList";
    Commands.INSERT_LOWERCASE_ALPHABET_LIST = "insertLowercaseAlphabetList";
    Commands.INSERT_UPPERCASE_ROMAN_LIST = "insertUppercaseRomanList";
    Commands.INSERT_LOWERCASE_ROMAN_LIST = "insertLowercaseRomanList";

    Commands.INDENT = "indent";
    Commands.OUTDENT = "outdent";

    Commands.MODE = "mode";
    Commands.FIND_AND_REPLACE = "findAndReplace";
    Commands.LINK = "link";
    Commands.INSERT_TEXT = "insertText";

    /* Toolbar Modes*/
    var ToolbarMode = ns.ToolbarMode = {};
    ToolbarMode.BASIC = "basic";
    ToolbarMode.FULL = "full";

    var Keyboard = ns.Keyboard = {};

    Keyboard.KEYCODE_B = 66;
    Keyboard.KEYCODE_I = 73;
    Keyboard.KEYCODE_U = 85;
    Keyboard.KEYCODE_S = 83;
    Keyboard.KEYCODE_E = 69;
    Keyboard.KEYCODE_L = 76;
    Keyboard.KEYCODE_R = 82;
    Keyboard.KEYCODE_J = 74;
    Keyboard.KEYCODE_GREATER_THAN = 190;
    Keyboard.KEYCODE_LESS_THAN = 188;

})(Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    "use strict";

    /* Default Editor configurations*/
    ns.DefaultConfig = {
        fontFamily : {
            defaultValue : "Times New Roman",
            options : ["Times New Roman", "Arial", "Courier", "Courier New", "Geneva", "Georgia", "Helvetica", "Tahoma", "Times", "Verdana"]
        },
        fontSize : {
            defaultValue : 12,
            options : [8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 26, 28, 36, 48, 72]
        },
        lineHeight : {
            options : [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
        },
        letterSpacing : {
            defaultValue : "0",
            options : ["0", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
        },
        header : {
            defaultValue : "p",
            options : [
                {
                    value : "p",
                    label : "None"
                },
                {
                    value : "h1",
                    label : "Header 1"
                },
                {
                    value : "h2",
                    label : "Header 2"
                },
                {
                    value : "h3",
                    label : "Header 3"
                },
                {
                    value : "h4",
                    label : "Header 4"
                },
                {
                    value : "h5",
                    label : "Header 5"
                },
                {
                    value : "h6",
                    label : "Header 6"
                }
            ]
        },
        color : {
            white : 'fff',
            red : 'f00',
            orange : 'f60',
            yellow : 'ff0',
            green : '008000',
            blue : '00f',
            purple : '800080',
            black : '000'
        }
        //TODO : add configuration for Custom classes
    };

    /* Out of the box toolbar configuration provided */
    ns.ToolbarConfig = {
        defaultMode : 'basic',
        toolbars : {
            basic : {
                layout : [
                    {
                        name : "Header",
                        items : [ns.Commands.HEADER]
                    },
                    {
                        name : "Paragraph",
                        items : [ns.Commands.BOLD, ns.Commands.ITALIC, ns.Commands.UNDERLINE]
                    },
                    {
                        command : 'lists',
                        title : "List Type",
                        icon : 'list',
                        type : 'popover',
                        placement : 'bottom',
                        items : [ns.Commands.INSERT_UNORDERED_LIST,
                            ns.Commands.INSERT_ORDERED_LIST,
                            ns.Commands.INSERT_LOWERCASE_ALPHABET_LIST]
                    },
                    {
                        title : 'Expand',
                        command : ns.Commands.MODE,
                        value : ns.ToolbarMode.FULL,
                        icon : 'resize-full'
                    }
                ],
                floating : true
            },
            full : {
                layout : [
                    {
                        items : [ns.Commands.UNDO, ns.Commands.REDO, ns.Commands.LINK, ns.Commands.FIND_AND_REPLACE]
                    },
                    {
                        name : "Paragraph",
                        items : [
                            ns.Commands.HEADER,
                            ns.Commands.FONT_FAMILY,ns.Commands.FONT_SIZE,
                            ns.Commands.BOLD, ns.Commands.ITALIC, ns.Commands.UNDERLINE,
                            ns.Commands.SUPERSCRIPT, ns.Commands.SUBSCRIPT,
                            ns.Commands.LETTER_SPACING,
                            ns.Commands.LINE_HEIGHT,
                            ns.Commands.FORE_COLOR,
                            ns.Commands.HILITE_COLOR
                        ]
                    },
                    {
                        name : "Alignment",
                        items : [
                            ns.Commands.JUSTIFY_LEFT, ns.Commands.JUSTIFY_CENTER, ns.Commands.JUSTIFY_FULL, ns.Commands.JUSTIFY_RIGHT,
                            ns.Commands.MARGIN_LEFT, ns.Commands.MARGIN_RIGHT, ns.Commands.MARGIN_TOP, ns.Commands.MARGIN_BOTTOM
                        ]
                    },
                    {
                        name : "Listing",
                        items : [ns.Commands.INSERT_UNORDERED_LIST,
                                ns.Commands.INSERT_ORDERED_LIST,
                                ns.Commands.INSERT_UPPERCASE_ALPHABET_LIST,
                                ns.Commands.INSERT_LOWERCASE_ALPHABET_LIST,
                                ns.Commands.INSERT_UPPERCASE_ROMAN_LIST,
                                ns.Commands.INSERT_LOWERCASE_ROMAN_LIST,
                                ns.Commands.INDENT, ns.Commands.OUTDENT
                        ]
                    },
                    {
                        title : 'Collapse',
                        command : ns.Commands.MODE,
                        value : ns.ToolbarMode.BASIC,
                        icon : 'resize-small',
                        selected : true
                    }
                ]
            }
        }
    };
})(Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/29/2016.
 */

(function (ns) {

    var FindAndReplace = ns.FindAndReplace = function (textEditor) {
        this.textEditor = textEditor;
        this._message = "";
        this._wholeWordEnabled = true;
        this.isDirty = true;
        this.isValid = true;
        Object.defineProperties(this, {"source" : {"get" : function () {
            return this.textEditor && this.textEditor.editor && this.textEditor.editor.composer && this.textEditor.editor.composer.container ? this.textEditor.editor.composer.container.textContent || this.textEditor.editor.composer.container.outerText : "";
        }}});
        Object.defineProperties(this, {"message" : {"get" : function () {
            return this._message;
        }, "set" : function (value) {
            this._message = value;
        }}});
        Object.defineProperties(this, {"wholeWordEnabled" : {"get" : function () {
            return this._wholeWordEnabled;
        }, "set" : function (value) {
            this._wholeWordEnabled = value;
        }}});
    };

    FindAndReplace.prototype.setSelectionAndHighlight = function (container, relativeStart, relativeEnd) {
        if (container == null) {
            container = this.textEditor.container;
            if (!container) {
                return;
            }
        }
        var charIndex = 0, range = document.createRange();
        range.setStart(document, 0);
        range.collapse(true);
        var nodeStack = [container], node, foundStart = false, stop = false;
        var newLineCount = 0;
        while (!stop && (node = nodeStack.pop())) {
            if (node && node.nodeType == 3) {
                var nextCharIndex = charIndex + node.nodeValue.length;
                if (this.relativeStart >= charIndex && this.relativeStart <= nextCharIndex) {
                    range.setStart(node, this.relativeStart - charIndex);
                    foundStart = true;
                }
                if (foundStart && this.relativeEnd >= charIndex && this.relativeEnd <= nextCharIndex) {
                    range.setEnd(node, this.relativeEnd - charIndex);
                    stop = true;
                }
                charIndex = nextCharIndex;
            } else {
                var i = node.childNodes.length;
                while (i--) {
                    nodeStack.push(node.childNodes[i]);
                }
            }
        }

        var sel = document.getSelection();
        sel.removeAllRanges();
        sel.addRange(range);
    };

    FindAndReplace.prototype.onRegExpSelectionChange = function () {
        this.onSelectionChange();
        this.setWholeWordEnabled();
    };

    FindAndReplace.prototype.onFindValueChange = function (findVal) {
        if (findVal != this.findText) {
            this.findText = findVal;
        }
        this.onSelectionChange();
        this.setWholeWordEnabled();
    };

    FindAndReplace.prototype.onReplaceValueChange = function () {
        this.onSelectionChange();
    };

    FindAndReplace.prototype.setWholeWordEnabled = function () {
        if (this.findText) {
            var result = ns.util.StringHelper.restrict(this.findText, "^`~!@#%&*()=+[]{}/\|'\";:/?.><,");
            if (this.findText != result) {
                this.wholeWordEnabled = false;
            } else if (this.isRegEx) {
                this.wholeWordEnabled = !this.isRegEx;
            } else {
                this.wholeWordEnabled = true;
            }
            if (!this.wholeWordEnabled) {
                this.isWholeWord = false;
            }
        }
    };

    FindAndReplace.prototype.onSelectionChange = function (isCaseSensitiveVal, isWholeWordVal, isRegExVal) {
        this.isDirty = true;
        this.relativeStart = -1;
        this.relativeEnd = -1;
        this.message = "";

        if (isWholeWordVal !== undefined && isWholeWordVal != null) {
            this.isWholeWord = isWholeWordVal;
        }
        if (isRegExVal !== undefined && isRegExVal != null && this.isRegEx !== isRegExVal) {
            this.isRegEx = isRegExVal;
            this.setWholeWordEnabled();
        }
        if (isCaseSensitiveVal !== undefined && isCaseSensitiveVal != null) {
            this.isCaseSensitive = isCaseSensitiveVal;
        }
    };

    FindAndReplace.prototype.clear = function () {
        this.isValid = this.findText ? true : false;
        this.isDirty = true;
        this.message = "";
        this.relativeStart = -1;
        this.relativeEnd = -1;
    };

    FindAndReplace.prototype.executeFind = function (findVal) {
        this.findText = findVal;
        if (this.findText) {
            this.findPosition(this.findText);
            this.setSelectionAndHighlight(null, this.relativeStart, this.relativeEnd, true);
        }
    };

    FindAndReplace.prototype.adjustSearchPositionAfterReplace = function (newVal) {
        if (this.relativeEnd != -1 || this.relativeStart != -1) {
            this.relativeEnd = this.relativeStart + newVal.length;
        }
    };

    FindAndReplace.prototype.executeReplace = function (findVal, replaceVal) {
        this.findText = findVal;
        if (findVal) {
            this.replace(findVal, replaceVal);
            this.executeFind(findVal);
        }
    };

    FindAndReplace.prototype.executeReplaceAll = function (findVal, replaceVal) {
        this.findText = findVal;
        if (findVal) {
            this.replaceAll(findVal, replaceVal);
        }
    };

    FindAndReplace.prototype.createRegExp = function (searchText) {
        if (this.isDirty || !this.regExp) {
            if (this.isRegEx && this.isCaseSensitive) {
                this.regExp = new RegExp(searchText, "g");
            } else if (this.isWholeWord && this.isCaseSensitive) {
                this.regExp = new RegExp("\\b" + searchText + "\\b", "g");
            } else if (this.isWholeWord) {
                this.regExp = new RegExp("\\b" + searchText + "\\b", "ig");
            } else {
                this.regExp = new RegExp(searchText, "ig");
            }
            this.isDirty = false;
        }
    };
    FindAndReplace.prototype.findPosition = function (search) {
        if (this.isRegEx || this.isWholeWord) {
            this.findPositionWithRegExp(search);
        } else {
            this.findPositionWithIndexOf(search);
        }
    };
    FindAndReplace.prototype.findPositionWithRegExp = function (search) {
        if (this.isDirty || !this.regExp) {
            this.createRegExp(search);
        }
        var result = this.regExp.exec(this.source);
        if (result && result.hasOwnProperty("index")) {
            this.setPosition(result.index, result.index + result[0].length);
        } else {
            this.setPosition(-1, -1);
        }
    };

    FindAndReplace.prototype.findPositionWithIndexOf = function (search) {
        var modifiedSource = this.source;
        var startFrom = 0;
        if (this.isDirty) {
            startFrom = 0;
            this.isDirty = false;
        } else {
            startFrom = this.relativeEnd;
        }
        if (!this.isCaseSensitive) {
            modifiedSource = this.source.toLocaleLowerCase();
            search = search.toLocaleLowerCase();
        }
        var start = modifiedSource.indexOf(search, startFrom);
        var end = start != -1 ? start + search.length : -1;
        this.setPosition(start, end);
    };
    FindAndReplace.prototype.setPosition = function (start, end) {
        if ((start == -1 || end == -1) && this.relativeEnd > 0) {
            this.message = ns.I18n.get("Reached end of module.");
        } else if (start == -1 || end == -1) {
            this.message = ns.I18n.get("Match Not Found");
        } else {
            this.message = "";
        }
        this.relativeStart = start;
        this.relativeEnd = end;
    };
    FindAndReplace.prototype.replace = function (search, replaceWith) {
        if (this.relativeStart == -1 || this.relativeEnd == -1) {
            this.findPosition(search);
        }
        this.replaceValue(replaceWith);
    };

    FindAndReplace.prototype.replaceAll = function (search, replaceWith) {
        var replaceCount = 0;
        this.relativeStart = this.relativeEnd = -1;
        this.findPosition(search);
        while (this.relativeStart != -1) {
            replaceCount++;
            this.replaceValue(replaceWith);
            this.findPosition(search);
        }
        this.message = replaceCount == 0 ? ns.I18n.get("Match Not Found") : ns.I18n.get("{0} matches replaced", [replaceCount]);
    };
    FindAndReplace.prototype.replaceValue = function (replaceWith) {
        if (this.textEditor) {
            this.setSelectionAndHighlight(null, this.relativeStart, this.relativeEnd, false);
            this.textEditor.executeCommand("insertText", replaceWith);
            this.adjustSearchPositionAfterReplace(replaceWith);
        }
    };

})(Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/27/2016.
 */

(function ($, ns) {
    "use strict";

    Handlebars.registerHelper('I18n', function (object) {
        return new Handlebars.SafeString(ns.I18n.get(object));
    });

    var commands = {
        undo : {
            title : 'Undo',
            text : 'Undo',
            icon : 'ccw'
        },
        redo : {
            title : 'Redo',
            text : 'Redo',
            icon : 'cw'
        },
        bold : {
            title : 'Bold',
            icon : 'bold'
        },
        italic : {
            title : 'Italic',
            icon : 'italic'
        },
        underline : {
            title : 'Underline',
            icon : 'underline',
            'class' : 'rte-custom-icon'
        },
        superscript : {
            title : 'Super-script',
            icon : 'superscript'
        },
        subscript : {
            title : 'Sub-script',
            icon : 'subscript'
        },
        foreColor : {
            title : 'Text Color',
            type : 'colorInput',
            icon : 'text-color'
        },
        hiliteColor : {
            title : 'Highlight Color',
            type : 'colorInput'
        },
        fontFamily : {
            type : 'select',
            title : 'Font Family'
        },
        fontSize : {
            type : 'select',
            title : 'Font Size'
        },
        lineHeight : {
            type : 'select',
            command : 'changeLineHeight',
            title : 'Line Height'
        },
        letterSpacing : {
            type : 'select',
            title : 'Letter Spacing'
        },
        header : {
            type : 'select',
            title : 'Paragraph Format'
        },
        justifyLeft : {
            title : 'Justify Left',
            icon : 'align-left'
        },
        justifyCenter : {
            title : 'Justify Center',
            icon : 'align-center'
        },
        justifyFull : {
            title : 'Justify Full',
            icon : 'align-justify'
        },
        justifyRight : {
            title : 'Justify Right',
            icon : 'align-right'
        },
        marginLeft : {
            type : 'numberInput',
            title : 'Margin Left'
        },
        marginRight : {
            type : 'numberInput',
            title : 'Margin Right'
        },
        marginTop : {
            type : 'numberInput',
            title : 'Margin Top'
        },
        marginBottom : {
            type : 'numberInput',
            title : 'Margin Bottom'
        },
        insertUnorderedList : {
            title : 'Bulleted List',
            icon : "list"
        },
        insertOrderedList : {
            command : "insertOrderedList",
            value : "Ordered",
            title : "Numbered List",
            icon : "textNumbered",
            'class' : "rte-custom-icon"
        },
        insertUppercaseAlphabetList : {
            command : "insertOrderedList",
            element : "rte_caps_alpha_list_command",
            value : "A",
            title : "Upper-case Alphabet List",
            icon : "textLetteredUppercase",
            'class' : "rte-custom-icon"
        },
        insertLowercaseAlphabetList : {
            command : "insertOrderedList",
            element : "rte_alpha_list_command",
            value : "a",
            title : "Lower-case Alphabet List",
            icon : "textLetteredLowercase",
            'class' : "rte-custom-icon"
        },
        insertUppercaseRomanList : {
            command : "insertOrderedList",
            element : "rte_caps_roman_list_command",
            value : "I",
            title : "Upper-case Roman List",
            icon : "textRomanUppercase",
            'class' : "rte-custom-icon"
        },
        insertLowercaseRomanList : {
            command : "insertOrderedList",
            element : "rte_roman_list_command",
            value : "i",
            title : "Lower-case Roman List",
            icon : "textRomanLowercase",
            'class' : "rte-custom-icon"
        },
        indent : {
            title : 'Indent',
            icon : "indent-left"
        },
        outdent : {
            title : 'Outdent',
            icon : "indent-right"
        },
        findAndReplace : {
            text : "Find & Replace",
            icon : 'search',
            type : 'popover',
            content : Handlebars.templates.findAndReplace(),
            callback : "Form.rte.CommandStateCallbacks.setFindAndReplaceMessage",
            placement : 'bottom'
        },
        link : {
            title : "Insert Link",
            icon : 'link',
            type : 'popover',
            content : Handlebars.templates.link(),
            placement : 'bottom'
        }
    };

    ns.Toolbar = function (options, config) {
        this.toolbars = (options && options.toolbars) || ns.ToolbarConfig.toolbars;
        this.modes = {};
        this.mode = (options && options.defaultMode) || ns.ToolbarConfig.defaultMode;
        this.config = config;
    };

    /**
     * Renders the toolbar specific to current mode
     * @returns {*}
     */
    ns.Toolbar.prototype.render = function () {
        var mode = this.mode;
        var config = this.config;
        if (!this.modes.hasOwnProperty(mode)) {
            var toolbarHTML = "";
            var modeConfig = this.toolbars[mode];
            try {
                var layout = modeConfig.layout;
                if (layout instanceof Array) {
                    layout.forEach(function (item) {
                        toolbarHTML += renderCommands(item, config);
                    });
                }
                this.modes[mode] =  $(Handlebars.templates.rtetoolbar(toolbarHTML));
            } catch (e) {
                console.error("Error in constructing Toolbar : " + e);
            }
        }
        return this.modes[mode];
    };

    /**
     * Set current mode of the Toolbar
     * @param mode
     */
    ns.Toolbar.prototype.setMode = function (mode) {
        this.mode = mode;
        return this.render();
    };

    /**
     * Returns current mode of the Toolbar
     * @returns Current mode
     */
    ns.Toolbar.prototype.getMode = function () {
        return this.mode;
    };

    ns.Toolbar.prototype._toggleFloatingToolbar = function (rte, toolbar, e, show) {
        var editor = rte.$element.find(".wysihtml5-editor")[0],
            editorFocused = show || editor.contains(e.target) || editor == e.target,
            toolbarFocused = e && toolbar.has(e.target);
        if (editorFocused) {
            toolbar.show();
            var offset = $(editor).offset();
            toolbar.offset({
                top : offset.top - toolbar.height() - 4,
                left : offset.left
            });
        } else if (!toolbarFocused || toolbarFocused.length == 0) {
            toolbar.hide();
        }
    };

    ns.Toolbar.prototype.initializeToolbarEvents = function (rte) {
        var mode = this.mode;
        if (this.modes.hasOwnProperty(mode)) {
            var toolbar = this.modes[mode];
            if (this.toolbars && this.toolbars[mode] && this.toolbars[mode].floating && !this.toggleToolbar) {
                /* Add focus handler to editor if the toolbar is of floating nature */
                this.toggleToolbar = $.proxy(this._toggleFloatingToolbar, this, rte, toolbar);
                $(document).on("mouseup", this.toggleToolbar);
            }
            var self = this;
            /* Listen for mode change on toolbar */
            if (toolbar.hasClass("initialized")) {
                return;
            }
            toolbar.find("[data-wysihtml5-command='mode']").on("click", function () {
                var mode = this.getAttribute("data-wysihtml5-command-value");
                $(self).trigger("modeChanged", mode);
            });
            var colors = rte.editorConfig ? rte.editorConfig.color : {};
            toolbar.find(".rte-colorInput-control:not(.pick-a-color)").pickAColor({
                touchOnlyMode : false, // for touch-only devices [tablet, smartphone, etc.]
                showSpectrum : true,
                showSavedColors : false,
                saveColorsPerElement : false,
                fadeMenuToggle : true,
                showAdvanced : true,
                showBasicColors : true,
                showHexInput : false,
                basicColors : colors
            }).on('change', function (e) {
                rte.executeCommand(e.target.getAttribute("data-wysihtml5-command"), "#" + e.target.value);
            });

            for (var color in colors) {
                if (colors.hasOwnProperty(color)) {
                    var selector = toolbar.find(".pick-a-color-markup .spectrum-" + color);
                    ns.util.RTEUtils.addSpectrumGradient(selector, colors[color]);
                }
            }
            toolbar.on("click", ".rte-popover > button", function () {
                var popover = $(this).siblings(".popover");
                var offset = $(this).offset();
                offset.top += this.clientHeight;
                popover.toggle();
                popover.offset(offset);
            });
            toolbar.on("click", ".rte-popover > .rte_link_command", function () {
                var popover = $(this).siblings(".popover");
                if (popover) {
                    var text = rte.composer && rte.composer.selection ? rte.composer.selection.getText() : "";
                    popover.find("input[name='alt']").val(text);
                }
            });

            toolbar.on("click", ".rte-popover .popover [rte-close]", function () {
                var popover = $(this).closest(".popover");
                popover.hide();
            });

            this._toggleFloatingToolbar(rte, toolbar, null, true);
            toolbar.addClass("initialized");
        }
    };

    var renderCommands = function (commandObj, config) {
        var html = "";
        var itemConfig;
        if (typeof commandObj == "string") {
            /* Fetch configuration from OOTB command if present */
            if (commands && commands.hasOwnProperty(commandObj)) {
                itemConfig = commands[commandObj];
                itemConfig.command = itemConfig.command || commandObj;
            }
        } else if (typeof commandObj == "object") {
            /* Fetch configuration from OOTB command if present */
            itemConfig = $.extend(commands[commandObj.command], commandObj);
        }
        if (itemConfig) {
            if (config && config.hasOwnProperty(commandObj)) {
                itemConfig = $.extend(itemConfig, config[commandObj]);
            }
            if (itemConfig.items) {
                itemConfig.type = itemConfig.type ||  "group";
                itemConfig.content = "";
                itemConfig.items.forEach(function (i) {
                    itemConfig.content += renderCommands(i, config);
                });
            }
            /* templateType defaults to group if it contains any items else defaults to button*/
            itemConfig.type = itemConfig.type || "button";
            itemConfig.element = itemConfig.element || "rte_" + itemConfig.command + "_command";
            if (Handlebars.templates.hasOwnProperty(itemConfig.type)) {
                html += Handlebars.templates[itemConfig.type](itemConfig);
            } else {
                console.error("Unable to retrieve template for " + itemConfig.type);
            }
        }
        return html;
    };
})($, Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/27/2016.
 */

(function (document, ns) {

    var callbackFunctions = ns.CommandStateCallbacks = {};

    /**
     * Callback to set Button state corresponding to command
     * @param domElem element to set state on
     * @param state whether command executed or not
     */
    callbackFunctions.setButtonState = function (domElement, state) {
        state = !(state == undefined || state == false);
        if (domElement) {
            if (state) {
                domElement.classList.add("active");
            } else {
                domElement.classList.remove("active");
            }
        }
    };

    /**
     * Callback to set Dropdown state corresponding to command
     * @param value value of the dropdown to set
     * @param domElement element to set state on
     */
    callbackFunctions.setSelectState = function (domElement, value) {
        if (domElement) {
            var options = domElement.options,
                isOptionPresent = false;
            if (options) {
                for (var i = 0; i < options.length; i++) {
                    if (options[i].value == value) {
                        isOptionPresent = true;
                        break;
                    }
                }
            }
            if (!isOptionPresent) {
                value = "";
            }
            domElement.value = value;
        }
    };

    /**
     * Callback to set Number Input state corresponding to command
     * @param value value to set
     * @param numberInput element to set value to
     */
    callbackFunctions.setNumberInputValue = function (numberInput, value) {
        if (numberInput) {
            numberInput.value = value;
        }
    };

    /**
     * Callback to set Find & Replace message
     * @param message message to set
     * @param findReplaceButton
     */
    callbackFunctions.setFindAndReplaceMessage = function (findReplaceButton, message) {
        var popover = $(findReplaceButton).siblings(".popover")[0];
        if (popover) {
            var messageEl = popover.querySelector(".rte_findNReplace_message");
            var alert = popover.querySelector(".rte_findNReplace_alert");
            if (messageEl && alert) {
                messageEl.innerHTML = message;
                if (message && message.trim() != "") {
                    $(alert).show();
                } else {
                    $(alert).hide();
                }
            }
        }
    };

    callbackFunctions.setColorInputValue = function (domElement, state, domElementName, cmd) {
        if (domElement) {
            var color = "rgb(0, 0, 0)";
            if (state && state.style) {
                if (cmd == Form.rte.Commands.FORE_COLOR) {
                    color = state.style.color;
                } else if (cmd == Form.rte.Commands.HILITE_COLOR) {
                    color = state.style.backgroundColor;
                }
            }
            $(domElement).closest(".pick-a-color-markup").find(".current-color").css("background-color", color);
        }
    };
})(document, Form.rte);


/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (document, ns) {
    "use strict";

    var ShortcutKeysCtrl = ns.ShortcutKeysCtrl = {};

    var getFontSize = function (next, composer, fontSizeList) {
        var fontSize = composer.commands.callbackState("fontSize");
        if (typeof fontSize === "string") {
            fontSize = parseFloat(fontSize);
        }
        if (fontSizeList && fontSizeList.length > 0) {
            var fontIndex = -1,
                i = 0,
                value = parseFloat(fontSizeList[i]);
            while (i < fontSizeList.length && value < fontSize) {
                value = parseFloat(fontSizeList[++i]);
            }
            if (value == fontSize) {
                fontIndex = next ? i + 1 : i - 1;
            } else {
                fontIndex = next ? i : i - 1;
            }
            if (fontIndex > -1 && fontIndex < fontSizeList.length) {
                return fontSizeList[fontIndex];
            }
        }
        return null;
    };

    ShortcutKeysCtrl.onkeydown = function (event, composer, config) {
        var isCtrl = event.ctrlKey,
            isAlt = event.altKey,
            isShift = event.shiftKey,
            which = event.which;
        if (isCtrl && isShift) {
            var fontSize = null,
                fontSizeOptions = config.fontSize ? config.fontSize.options : [];
            if (which == ns.Keyboard.KEYCODE_GREATER_THAN) {// Ctrl + Shift + > to Increase font size
                fontSize = getFontSize(true, composer, fontSizeOptions);
            } else if (which == ns.Keyboard.KEYCODE_LESS_THAN) {// Ctrl + Shift + < to Decrease font size
                fontSize = getFontSize(false, composer, fontSizeOptions);
            }
            if (fontSize) {
                event.preventDefault();
                composer.commands.exec("fontSize", fontSize, false);
            }
        } if (isCtrl) {
            var command = "";
            if (isAlt) {
                if (which == ns.Keyboard.KEYCODE_B) {// Ctrl + Alt + B for Bold
                    command = "bold";
                } else if (which == ns.Keyboard.KEYCODE_I) {// Ctrl + Alt + I for Italic
                    command = "italic";
                } else if (which == ns.Keyboard.KEYCODE_U) {// Ctrl + Alt + U for Underline
                    command = "underline";
                }
            } else {
                if (which == ns.Keyboard.KEYCODE_E) {// Ctrl + E for Center-Aligned Text
                    command = "justifyCenter";
                } else if (which == ns.Keyboard.KEYCODE_L) {//Ctrl + L for Left-Aligned Text
                    command = "justifyLeft";
                } else if (which == ns.Keyboard.KEYCODE_R) {//Ctrl + R for Right-Aligned Text
                    command = "justifyRight";
                } else if (which == ns.Keyboard.KEYCODE_J) {//Ctrl + J for Fully-Justified Text
                    command = "justifyFull";
                }
            }
            if (command != "") {
                event.preventDefault();
                composer.commands.exec(command, undefined, true);
            }
        }
    };

})(document, Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (document, $, ns) {
    "use strict";

    /**
     * Creates an instance of Rich Text Editor which takes object with following configurations :
     * Selector : selector or DOM element of Element for which RTE needs to be linked
     * Toolbar : selector of Toolbar or config to use custom Toolbar
     * data : HTML to be set while instantiating
     *
     * @type {RichTextEditor}
     */
    var RichTextEditor = ns.RichTextEditor = function (options) {

        var selector = typeof options.selector === "string" ? document.getElementById(options.selector) : options.selector;
        var toolbar = options.toolbar;
        ns.I18n.setLocale(options.locale);
        this.editorConfig = $.extend(ns.DefaultConfig, options.config);

        var insertAfter;
        var richTextEditor = $("<div class='forms-richTextEditor'></div>");
        if (!(toolbar instanceof HTMLElement || typeof toolbar == "string")) {
            /* Create out of the box toolbar is no toolbar DOM element or selector is provider*/
            this.toolbar = new ns.Toolbar(toolbar, this.editorConfig);
            this.$toolbar = this.toolbar.render();
            insertAfter = toolbar = this.$toolbar[0];
            richTextEditor.append(this.$toolbar);
            richTextEditor.addClass("rte-mode-" + this.toolbar.getMode());
        } else {
            insertAfter = $("<div></div>")[0];
            richTextEditor.append(insertAfter);
        }

        richTextEditor.insertAfter($(selector));
        this.$element = richTextEditor;

        var parserRules = wysihtml5SupportedParserRules;
        if (options.parserRules) {
            if (options.parserRules.tags) {
                parserRules.tags = $.extend(parserRules.tags, options.parserRules.tags);
            }
            if (options.parserRules.classes) {
                parserRules.classes = $.extend(parserRules.classes, options.parserRules.classes);
            }
            if (options.parserRules.styles) {
                parserRules.styles = parserRules.styles.concat(options.parserRules.styles);
            }
            if (options.parserRules.pseudoTags) {
                parserRules.pseudoTags = options.parserRules.pseudoTags;
            }
            if (options.parserRules.textNodes) {
                parserRules.textNodes = options.parserRules.textNodes.map(function (nodeName) {
                    return nodeName.toUpperCase();
                });
            }
        }

        if (window.hasOwnProperty("wysihtml5") && window.wysihtml5) {
            if (!this.editor) {
                this.editor = new wysihtml5.Editor(selector, {
                    toolbar : toolbar,
                    insertAfter : insertAfter,
                    useLineBreaks : false,
                    pasteAsPlainText : false,
                    stylesheets : options.cssPath,
                    defaultFontSize : this.editorConfig.fontSize.defaultValue,
                    parserRules : parserRules
                });
                if (this.editor.composer) {
                    var composer = this.editor.composer,
                        container = composer.container,
                        doc = composer.doc,
                        config = this.editorConfig;
                    if (container) {
                        for (var style in this.editorConfig) {
                            if (this.editorConfig.hasOwnProperty(style)) {
                                container.style[style] = this.editorConfig[style].defaultValue;
                            }
                        }
                    }
                    $(doc).on("keydown", function (e) {
                        ns.ShortcutKeysCtrl.onkeydown(e, composer, config);
                    });
                }
                if (options.data) {
                    this.setRichTextEditorContent(options.data);
                }
                var findAndReplace = this.findAndReplace = new ns.FindAndReplace(this);
                RichTextEditor.addCommand("changeLineHeight", {
                    exec : function (composer, commandName, value) {
                        wysihtml5.util.changeLineHeight(value, true, null, composer, true);
                    },
                    state : wysihtml5.commands.lineHeight.state,
                    callbackState : wysihtml5.commands.lineHeight.callbackState

                });
                RichTextEditor.addCommand("findAndReplace", {
                    state : function () {
                        return findAndReplace.message;
                    }
                });
                RichTextEditor.addCommand("find", {
                    focus : false,
                    exec : function (composer, commandName, values) {
                        if (values) {
                            findAndReplace.executeFind(values.findText);
                        }
                    }
                });
                RichTextEditor.addCommand("replace", {
                    focus : false,
                    exec : function (composer, commandName, values) {
                        if (values) {
                            findAndReplace.executeReplace(values.findText, values.replaceText);
                        }
                    }
                });
                RichTextEditor.addCommand("replaceAll", {
                    focus : false,
                    exec : function (composer, commandName, values) {
                        if (values) {
                            findAndReplace.executeReplaceAll(values.findText, values.replaceText);
                        }
                    }
                });
                RichTextEditor.addCommand("changeFindText", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onFindValueChange(value);
                    }
                });
                RichTextEditor.addCommand("changeReplaceText", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onReplaceValueChange(value);
                    }
                });
                RichTextEditor.addCommand("changeWholeWord", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onSelectionChange(undefined, value, undefined);
                    }
                });
                RichTextEditor.addCommand("changeMatchCase", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onSelectionChange(value);
                    }
                });
                RichTextEditor.addCommand("changeRegExp", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onSelectionChange(undefined, undefined, value);
                    }
                });
                if (this.toolbar) {
                    this.toolbar.initializeToolbarEvents(this);
                    $(this.toolbar).on("modeChanged", $.proxy(this.toggleToolbarMode, this));
                }
            }
        }
        Object.defineProperties(this, {"composer" : {"get" : function () {
            return (this.editor && this.editor.composer) ? this.editor.composer : null;
        }}});
        Object.defineProperties(this, {"container" : {"get" : function () {
            return (this.editor && this.editor.composer) ? this.editor.composer.container : null;
        }}});
        Object.defineProperties(this, {"doc" : {"get" : function () {
            return document;
        }}});
    };

    /**
     * Sets the html provided to the Rich Text Editor
     * @param htmlData Html to be inserted
     */
    RichTextEditor.prototype.setRichTextEditorContent = function (htmlData) {
        if (htmlData !== this.getRichTextEditorContent()) {
            htmlData = htmlData || "";
            var pattern = new RegExp('<br><\/br>', 'gi');
            htmlData = htmlData.replace(pattern, "<br>");
            if (htmlData.indexOf("<body") > -1) {
                htmlData = ns.util.HtmlUtils.extractBodyContent(htmlData);
            }
            this.editor.setValue(htmlData);
            if (this.editor.composer && this.editor.composer.undoManager) {
                this.editor.composer.undoManager.clearHistory();
            }
        }
    };

    /**
     * Fetches the current html from Rich Text Editor
     * @returns html from Rich Text Editor
     */
    RichTextEditor.prototype.getRichTextEditorContent = function () {
        var html = ns.util.HtmlUtils.richTextEditorToHtml(this.editor.getValue(), this.editorConfig);
        return ns.util.HtmlUtils.wrapInBody(html);
    };

    /**
     * Executes command(bold,italics,etc) on the Editor
     * @param command Name of the command
     * @param value value for the command
     * @param allowUndo whether undo to be enabled for the command or not
     */
    RichTextEditor.prototype.executeCommand = function (command, value, allowUndo) {
        if (arguments && arguments.length > 0) {
            if (this.editor && this.editor.composer) {
                this.editor.composer.commands.exec.apply(this, arguments, allowUndo);
            } else {
                window.console.error("Unable to find the Editor instance");
            }
        } else {
            window.console.error("Invalid command ");
        }
    };

    /**
     * Changes the toolbar mode
     * @param e Toolbar mode change Event
     * @param mode Mode for the toolbar to be enabled
     */
    RichTextEditor.prototype.toggleToolbarMode = function (e, mode) {
        this.$element.removeClass("rte-mode-" + this.toolbar.getMode());
        if (this.$toolbar) {
            $(this.toolbar).off("modeChanged");
            this.$toolbar.detach();
        }
        this.$toolbar = this.toolbar.setMode(mode);
        this.$element.prepend(this.$toolbar);
        this.$element.addClass("rte-mode-" + this.toolbar.getMode());
        this.editor.setToolbar(this.$toolbar[0]);
        this.toolbar.initializeToolbarEvents(this);
        $(this.toolbar).on("modeChanged", $.proxy(this.toggleToolbarMode, this));
    };

    RichTextEditor.addCommand = function (commandName, options) {
        wysihtml5.commands[commandName] = options;
    };

})(document, $, Form.rte);


/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2016 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/

window.xfalib.$ = window.$;
window.xfalib.jQuery = window.jQuery;
window.xfalib._ = window._;
/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *   ___________________
 *
 *    Copyright 2013 Adobe Systems Incorporated
 *    All Rights Reserved.
 *
 *   NOTICE:  All information contained herein is, and remains
 *   the property of Adobe Systems Incorporated and its suppliers,
 *   if any.  The intellectual and technical concepts contained
 *   herein are proprietary to Adobe Systems Incorporated and its
 *   suppliers and are protected by all applicable intellectual property
 *   laws, including trade secret and copyright laws.
 *   Dissemination of this information or reproduction of this material
 *   is strictly forbidden unless prior written permission is obtained
 *   from Adobe Systems Incorporated.
 ******************************************************************************/


;(function ($) {
    /*
     * Form Bridge API
     * The API provides a method for external applications to connect with Xfa and formDom. The APIs are divided into two categories, synchronous and asynchronous.
     *
     * All the APIs that are internal to us must go into FormBridgeInternal.js and not here
     *
     * Each Synchronous getter API returns a XFAResultObject which represents the result of the API whereas each setter API throws an exception in case of error and
     * it is the responsibility of the API to catch those exceptions. The XFAResultObject either contains error or the return value of the API and provides easy
     * mechanism to access each of them.
     *
     * Each Asynchronous API provides callback mechanism to return the result of the API. Each API takes a Javascript Object containing error, success Handlers and a
     * context in which to invoke those functions. The syntax of the object is
     * { error: errorHandlerFunc,
     *   success: successHandlerFunc,
     *   context: ObjectContext
     * }
     * The signature of the functions is
     * function(XFAResultObject) {
     *
     *  }
     * Each of the functions is passed a XFAResultObject containing either the data of the operation or the errors.
     *
     */

    Function.prototype.bind = Function.prototype.bind || function (ctx) {
        var that = this;
        return function () {
            that.call(ctx, arguments);
        }
    };

    /* public interface XFAResultObject
     public string[] message          // error messages
     public string[] somExpression    // somExpressions that caused the errors
     public string[] errorCode        // internal
     public bool errors               // whether the result object has errors or not
     public Object data               // data returned by the function

     public getNextMessage            // returns a message Object {code,somExpression,message} or null if no error message is present
     */
    var XFAResultObject = function() {
        var _message = [],
            _errorCode = [],
            _somExpression = [];
        this.errors = false;

        this.addMessage = function (code, msg, som) {
            this.errors = true;
            _message.push(msg);
            _somExpression.push(som);
            _errorCode.push(code);
        };

        this.getNextMessage = function () {
            if (_errorCode.length == 0)
                return null;
            return {
                code: _errorCode.pop(),
                somExpression: _somExpression.pop(),
                message: _message.pop()
            };
        };
    };

    var FORM_BRIDGE_VERSION = "8.1.16";
    var FormBridge = function () {
        this._xfa = null;
        this._version = FORM_BRIDGE_VERSION;
        this._xfaInitHandler = {};
        this._$target = null;
        this.isAnalyticsEnabled = false;
        $(window).on("XfaInitialized", this._xfaInitialized.bind(this));
        $(window).on("XfaInitializationError", this._xfaError);
        this._formDoc = window.document;
        this.userConfig = {};
        // indicates if ajax call is executed in client or server
        // note: this should not be modified in client
        this.ajaxCallMode = "client";
        this._PROFILE_RESOURCE_PATH = "/content/xfaforms/profiles/default";
    };

    /*
     * Default error handler for functions in case none is provided by the caller
     * TODO : make the string localized and call the xfa Logger
     */
    var defaultErrorHandler = function (obj) {
        if (typeof(console) == "undefined")
            return;
        var d = null;
        while (d = obj.getNextMessage())
            console.error(d.message);
    };

    var _isFirstTempStorageCreationPending = false,
        TEMP_STORAGE_PATH = "/tmp/fd/xfaforms";
    var createUUIDStorage  = function(uuid){
        if(!formBridge._isLoginAnonymous()) {
            var successFlag = true;
            $.ajax({
            url: formBridge._getPathUrl(".fd.tempstorageprovider.jsp"),
                type: "POST",
                async: false,
                data: {"uuidPath": TEMP_STORAGE_PATH + "/" + uuid},
                error : function (message) {
                    successFlag = false;
                }
            });
            return successFlag;
        }

    };

    /*
     * Default function to check Validations errors after getting the data from the
     * server with getDataXML call.
     */
    var defaultValidationChecker = function (validations, obj) {
        if (validations && validations.length > 0) {
            for (var i = 0; i < validations.length; i++)
                obj.addMessage(0, validations[i], "");
            return false;
        }
        return true;
    };

    $.extend(FormBridge.prototype, {
        /*
         * Returns whether Form Dom is initialized or not.
         */
        isConnected: function () {
            return !!this._xfa;
        },
        /*
         * @public
         * Specify a function to execute after making a connection with FormBridge
         * handler: handler to execute
         * context: variable 'this' will refer to context in the handler.
         */
        connect: function (handler, context) {
            context = context || formBridge;
            if (this.isConnected())
                handler.call(context);
            else {
                this._xfaInitHandler.handler = this._xfaInitHandler.handler || [];
                this._xfaInitHandler.handler.push(handler);
                this._xfaInitHandler.context = this._xfaInitHandler.context || [];
                this._xfaInitHandler.context.push(context);
            }
        },
        /*
         * @private
         * Handler for XfaInitialized event which is fired by XFA library after Form Dom is initialized
         */
        _xfaInitialized: function (e) {
            this._xfa = xfalib.runtime.xfa;
            var obj = new XFAResultObject();
            if (this.storage) {
                if (this.storage.formState) {
                    this._xfa.host.playJson(JSON.parse(this.storage.formState.xfaDom));
                    this.storage.success.call(this.storage.context);
                    this.storage = null;
                } else if (this.storage.success) {
                    this.storage.success.call(this.storage.context);
                }
                if (this.xmlStorage && this.xmlStorage.xmlDocument) {
                    try {
                        this._xfa.Logger.debug("xfa", "Restoring Data XML after initiailzation");
                        this._xfa.host.playDataXml(this.xmlStorage.xmlDocument);
                        if(this.xmlStorage.success) {
                            this.xmlStorage.success.call(this.xmlStorage.context, obj);
                        }
                    } catch(e) {
                        if(this.xmlStorage.error) {
                            obj.addMessage(2, "Unexpected Exception: Unable to play Data XML " + e, null);
                            this.xmlStorage.error.call(this.xmlStorage.context, obj);
                        }
                    }
                } else if (this.xmlStorage && this.xmlStorage.success) {
                    this.xmlStorage.success.call(this.xmlStorage.context, obj);
                }
                this.xmlStorage = null;
            }
            if (this._xfaInitHandler.handler) {
                for (var i = 0; i < this._xfaInitHandler.handler.length; i++) {
                    this._xfaInitHandler.handler[i].call(this._xfaInitHandler.context[i]);
                }
                this._xfaInitHandler = {};
            }
        },

        /*
         * @public
         * Specify a function to decide whether the analytics will be enabled or disabled
         * public Boolean isAnalyticsEnabled: this argument determines whether the analytics will be enabled or not
         */
        enableAnalytics: function(state){
            this.isAnalyticsEnabled = state;
        },

        _xfaError: function (e) {
            this._xfa = window.xfa;
            var obj = new XFAResultObject();
            // since there is xfa init error, why should we call playJson
            if (this.storage.formState) {
                this._xfa.host.playJson(JSON.parse(this.storage.formState.xfaDom));
                this.storage = null;
            } else {
                if (this.storage.error)
                    this.storage.error.call(this.storage.context, e.message);
            }
            if (this.xmlStorage.error) {
                obj.addMessage(2, e.message, null);
                this.xmlStorage.error.call(this.xmlStorage.context, obj);
            }
        },

        _getResultObject: function() {
            return new XFAResultObject();
        },

        _checkXfa: function (obj) {
            if (!this._xfa) {
                obj.addMessage(1, "Xfa Dom not Initialized", "");
                return false;
            }
            return true;
        },
        /*
         * returns the version of library
         */
        getBridgeVersion: function () {
            return this._version;
        },

        /*
         * Registers user/portal specific configurations to FormBridge.
         * Currently supported configurations are:
         * {widgetConfig : {selector: jqWidgetName}}
         * {pagingConfig : {pagingEnabled: true}}
         * {LoggerConfig : {{"on":"true", "category":"xfa", "level":"5", "type":"console"}}
         * {postExternalMessageConfig : {postExternalHandler: fn}}
         * {contextPath : contextPath}
         * {viewportWidth : <1000>}
         * e.g.: formBridge.registerConfig("widgetConfig", {".imagefield" : "sigImageField"});
         *
         * returns a XFAResultObject. Old config against same key is stored in obj.data[0]
         */
        registerConfig: function (key, config) {
            var obj = new XFAResultObject();
            obj.data = this.userConfig[key];
            this.userConfig[key] = config;
            obj.completed = true;
            return obj;
        },


        /*
         * Returns the pagingManager handle for the current xfa view.
         * Should be called after FormBridge is in connected mode else paginManager handle would be null
         */
        pagingManager: function () {
            if (this._xfa && this._xfa.host)
                return this._xfa.host.pagingManager;
            else
                return null;
        },

        /*
         * hide the fields whose som is provided in the fieldArray
         * fieldArray: array of somExpressions
         */
        hideFields: function (fieldArray) {
            this.setFieldProperties(fieldArray, "presence", "invisible");
        },
        /*
         * Make the fields, whose som is provided in the fieldArray, visible
         * fieldArray: array of somExpressions
         */
        showFields: function (fieldArray) {
            this.setFieldProperties(fieldArray, "presence", "visible");
        },
        /*
         * set the value of the field. Throws an exception if the somExpression is incorrect
         * field: somExpressions of the field
         */
        setFieldValue: function (field, value) {
            this.setFieldProperties(field, "rawValue", value);
        },
        /*
         * get the value of the fields, whose som is provided in the fieldArray
         * fieldArray: array of somExpressions
         *
         * returns a XFAResultObject. The result is stored in obj.data[0]
         */
        getFieldValue: function (field) {
            return this.getFieldProperties(field, "rawValue");
        },
        /*
         * set the property of the fields, whose som is provided in the fieldArray, with the values provided
         * fieldArray: array of somExpressions
         * prop: property to set
         * values: array of values.
         */
        setFieldProperties: function (fieldArray, prop, values) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                throw obj.getNextMessage().message;

            if (!_.isArray(fieldArray)) {
                fieldArray = [fieldArray];
            }

            if (!_.isArray(values)){
                values = [values];
            }

            for (var i = 0; i < fieldArray.length; i++) {
                var field = this._xfa.resolveNode(fieldArray[i]);
                if (field == null)
                    throw "No field " + fieldArray[i] + " exists"
                else {
                    obj.completed = true;
                    field[prop] = values[i] || values[0];
                }
            }
            // change made to re-evaluate floating field text in draw
            if(prop && prop === "rawValue" && this._xfa.moContextNodes.length == 0) {
                this._xfa.runCalcAndValidate();
            }
        },
        /*
         * get the property value of the fields, whose som is provided in the fieldArray
         * fieldArray: array of somExpressions
         * prop: property to get
         *
         * returns a XFAResultObject whose data member is the array of returned values. If a
         * somExpression provided doesn't exists null is returned for that element in the data
         */
        getFieldProperties: function (fieldArray, prop) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                return obj;

            if (!_.isArray(fieldArray)) {
                fieldArray = [fieldArray];
            }

            obj.data = [];
            for (var i = 0; i < fieldArray.length; i++) {
                var field = this._xfa.resolveNode(fieldArray[i]);
                if (field == null) {
                    obj.addMessage(0, "No field " + fieldArray[i] + " exists", fieldArray[i])
                    obj.data.push(null);
                }
                else {
                    obj.completed = true;
                    obj.data.push(field[prop]);
                }
            }
            return obj;
        },
        hideSubmitButtons: function () {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                throw obj.getNextMessage().message;
            this._xfa._hideSubmitButtons();
        },
        _getPathUrl: function (urlSuffix) {
            var url = this._PROFILE_RESOURCE_PATH + (urlSuffix || "");
            return this._getUrl(url);
        },

        _getFileWidgetIfPresent: function () {
            return xfalib.runtime.fileUploadWidget;

        },
        _getFileListFromFileWidget:  function () {
            var fileWidget = this._getFileWidgetIfPresent();
            if(fileWidget) {
                return fileWidget._getFileList();
            }
            return null;
        },
        _getCommitValueFromFileWidget: function () {
            var fileWidget = this._getFileWidgetIfPresent();
            if(fileWidget) {
                return fileWidget.getCommitValue();
            }
            return null;
        },

        /**
         *
         * @param optimize{boolean} flag to turn optimization on; if false, entire jsonModel is returned,
         * else diff of initial and current model returned.
         * @param optimize_level{0,1 or 2} : determines the aggressiveness level of size optimizations used
         *  0: returns all properties which changed between initial and current model.
         *  1: jsonModelDiff with access & presence, must be repayable via playJson on calling restoreFormState. but to keep diff sz to min.
         *      remove unplayed items from the diff. Also to maintain hierarchy must have all instance managers, and unbinded fields.
         *  2: minimal jsonModelDiff with only hierarchy skeleton and class, name and 'value's preserved for transfer during submit.
         *
         * @returns {XFAResultObject}
         * returns the string representation of the XFA Form DOM and includes all the XFA packets
         * returns a XFAResultObject whose 'data' member is the formState
         */
        getFormState: function (optimize, optimize_level) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj)) {
                return obj;
            }
            var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
            //To maintain backward compatibility
            if (behaviorConfig.isOn('disableLeanSubmit') || behaviorConfig.isOn('mfDisableLeanSubmit')) {
                optimize_level = 0;
            }
            var xfaDom = optimize === true ? this._xfa._computeJsonDiff(optimize_level).jsonDifference
                                           : this._xfa.jsonModel;

            xfaDom.isComplete = !optimize;

            //add the information required from DOM during submit in the form state
            var formAttributesData = {},
                formElement = $("#lcforms_xfaform_container")[0];
            if(formElement){
                _.each(formElement.attributes,function(attrib){
                    formAttributesData[attrib.name] = attrib.value;
                });
            }

            var additionalSubmitInformation = {
                "formAttributesData": formAttributesData,
                "userConfig": formBridge.userConfig
            };

            var xfaDomString = JSON.stringify(xfaDom);
            obj.data = {
                xfaDom: xfaDomString,
                //save renderContext in form state to enable deferred submit even if form is not open
                renderContext: xfalib.runtime.renderContext,
                customPropertyMap: xfalib.runtime.customPropertyMap,
                additionalSubmitInformation: additionalSubmitInformation
            };
            return obj;
        },
        /*
         * sets the field on focus whose somExpression is provided
         *
         * throws an exception in case of error.
         */
        setFocus: function (som) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                throw obj.getNextMessage().message;
            var node = this._xfa.resolveNode(som);
            if (node == null) {
                throw "No field " + som + " exists ";
            }
            else {
                this._xfa.host._setFocus(som);
            }
        },

        /*
         *  Helper function to ger submit service proxy url
         */
        _getSubmitServiceProxyUrl: function () {
            var submitServiceProxyConfig = this.userConfig["submitServiceProxyConfig"],
                submitServiceProxyUrl = "",
                contextPath = this.userConfig["contextPath"];
            if (submitServiceProxyConfig && submitServiceProxyConfig["submitServiceProxy"]) {
                submitServiceProxyUrl += submitServiceProxyConfig["submitServiceProxy"];
            }
            else {
                //finally hard code it
                submitServiceProxyUrl += ((contextPath && contextPath !== "/") ? contextPath : "") + "/content/xfaforms/profiles/default.submit.html";
            }
            return submitServiceProxyUrl;
        },

        /*
         * remote invocation ----
         * This method post form dom to LCFormsService and run the success handlers
         * It accepts the object with following params:
         * {
         *  url: '',
         *  type: '',
         *  contentType: '',
         *  data: '',
         *  success: '',
         *  error: ''
         *  }
         *  The called can choose to override one of more parameters of $.ajax API of JQuery
         */

        _invokeAtServer: function (options) {
            options = options || {};
            var submitServiceProxyUrl = this._getSubmitServiceProxyUrl(),
                isServerAjaxCallMode = this.ajaxCallMode === "server";

            if (options.data && !options.data["_charset_"]) {
                options.data["_charset_"] = "UTF-8"; //to let sling know data encoding
            }

            if(isServerAjaxCallMode){
                var mergedFormDom = "";
                // Done to fix: LC-9204
                // Not invoking HTTP request instead making use of server session
                try {
                    mergedFormDom = getMergedFormDomFromRhino(options.data);
                } catch(exception){
                    xfalib.runtime.xfa.Logger.error("xfa", exception.message);
                }
                // If success handler is present, invoke it, context is provided by the caller
                if(_.isFunction(options.success) && mergedFormDom) {
                    options.success(JSON.parse(mergedFormDom));
                }
            } else {
                var strContent = this.getMultipartData(options.data);  // TODO : maybe use the browser's FormData object, and handle IE as we are doing now
                options.data = strContent[1];
                var params = _.extend({
                        beforeSend: formBridge.uiFreeze,
                        complete: formBridge.uiUnFreeze,
                        async: false,
                        url: submitServiceProxyUrl,
                        type: 'POST',
                        processData: false,
                        cache: false,
                        contentType: "multipart/form-data; charset=UTF-8; boundary=" + strContent[0]
                    },
                    options);

                $.ajax(params);
            }
        },

        /**
         *
         * This function does following:
         * a) On first call, it creates the uuid storage and returns the UUID
         * b) On subsequent calls, it just returns the uuid
         * c) if uuid is not created then it returns null
         *
         */
        _getUUID: function () {
            if(this._formInstanceUUID) {
                return this._formInstanceUUID;
            }
            //Generate the UUID for the form instance on client side
            var uuid = $('body#formBody').data("tmproot"),
                uuidSuffix = Math.floor((Math.random() * 10000) + 1),
                uuidCurrentTime = new Date().getTime(),
                successFlag = true;
            this._formInstanceUUID = uuid + "_" + uuidCurrentTime + uuidSuffix;
            successFlag = createUUIDStorage(this._formInstanceUUID);
            if(successFlag){
                return this._formInstanceUUID;
            } else {
                return null;
            }
        },
        _getUrl: function (url) {
            //url provided can contain the hostname and port too, in that case return the url as it is
            if (url.indexOf("http:") == 0 || url.indexOf("https:") == 0) {
                return url;
            }
            var baseUrl = this.userConfig["baseUrl"],
                contextPath = this.userConfig["contextPath"];
            if (baseUrl) {
                return baseUrl + url;
            }
            else if (contextPath && contextPath!== "/" && url.indexOf(contextPath)!== 0 &&(url.length ===0 || url.indexOf("/") === 0)){
                //if url does not have contextPath and starts with /, pre-pend contextPath
                // Also url.length check because I need to pass "" to getUrl and get context path
                return contextPath + url;
            }
            return url;
        },
        getFileAttachmentsInfo: function (options) {
            var fileAttachmentsList = [],
                list;


            function collectFileUrls(event) {
                list = [];
                //TODO: need to modularize collectFileUrs()
                // here this is the context of the function who calls it
                _.each(this.attachments, function (att) {
                    //this.fileUrl is null when no file is uploaded. att contains path - "fileupload/™a.jpg" if not uploaded
                    // if att starts with "/", this means that the attachment has already been uploaded.
                    if(!_.isEmpty(this.fileUrl) && att.indexOf("/")!=0 ) {
                        list.push({name: att.split("/")[1], path: this.fileUrl + "/" + att});
                    } else {
                        list.push({name: att.substring(att.lastIndexOf("/")+1), path: att});
                    }
                }, this);
                if (this.options.success) {
                    this.options.success.call(this.options.context, list);
                }
            }

            this._getAttachments(fileAttachmentsList, options.fileUploadPath || this.getTempPath(), collectFileUrls, options);

        },

        _getAttachments: function (fileAttachmentDomElement, fileUploadPath, callback, options) {

            var allFiles = [],
                attachments = [],
                fileUrl = null,
                fileCount = 0,
                didSubmit = false,
                contextRoot = this._getContextRoot(),
                FILE_COMPONENT_NAME = "fileupload";

            /*
             * In the case of draft, url comes with context root. Need to remove it so that correct value gets stored in model
             */
            if (contextRoot) {
                if (fileUploadPath.indexOf(contextRoot) === 0) {
                    fileUploadPath = fileUploadPath.substring(contextRoot.length);
                }
            }

            var currentCount = 0;
            var fileNameList = formBridge._getCommitValueFromFileWidget();

            if (fileNameList.length > 0) {
                var fileNames = fileNameList;
                var fileList = $.extend(true, [], formBridge._getFileListFromFileWidget());
                _.each(fileList, function (file, index) {
                    var nameOfFile = fileNames[index],
                        completeNameOfFile = null;
                    if (nameOfFile != null && file != null) { //file can be null when you click save two times continuously without change in guide context
                        completeNameOfFile = FILE_COMPONENT_NAME + "/" + nameOfFile;
                        // case: if there is a file dome
                        if (!_.isString(file)) {
                            // Check if the value exist in the file, this is done because in IE9 and IE10 the list will
                            // have an extra empty dom
                            if ($(file).val().length > 0) {
                                $(file).attr('name', completeNameOfFile);
                                attachments[fileCount] = completeNameOfFile;
                                allFiles[fileCount++] = $(file);
                            }
                        } else {
                            // since there is no file dom in case of draft usecase, make it null
                            attachments[fileCount] = file;
                            allFiles[fileCount++] = null;
                        }
                    }
                }, this);


                if (allFiles.length > 0) {

                    // since there can be a dom element which is null, in case of draft usecase
                    // get the first non null file dom
                    var firstNonNullFileDom = _.indexOf(allFiles, _.find(allFiles, function (item) {
                        return item !== null;
                    }));
                    var uploaderPluginName = formBridge.userConfig.uploaderPluginName || "adobeFileUploader";
                    if (firstNonNullFileDom !== -1) {
                        fileUrl = allFiles[firstNonNullFileDom][uploaderPluginName]("uploadFile", {
                            'fileName': attachments,
                            'fileDom': allFiles,
                            'fileUploadPath': fileUploadPath,
                            'multiple': true,
                            '_uuidGenerator': function () { return formBridge._getUUID.apply(this); },
                            _getUrl: formBridge._getUrl("")
                        });

                        /*The file url returned by file upload widget can contain context root. Remove it so that correct value gets stored in model.*/
                        if (contextRoot) {
                            if (fileUrl.indexOf(contextRoot) === 0) {
                                fileUrl = fileUrl.substring(contextRoot.length);
                            }
                        }

                        allFiles[firstNonNullFileDom].one("adobeFileUploader.multipleFileUploaded", $.proxy(callback,
                            {
                                "attachments": attachments,
                                "fileUrl": fileUrl,
                                "options": options,
                                "_uuidGenerator": function () { return formBridge._getUUID.apply(this); }
                            })
                        );
                        didSubmit = true;
                    }
                }

            }

            if (!didSubmit) {
                // if there are no files attached, still call the callback to submit the json contents
                // if there is only one file attachment component with no files, in this case else is important
                callback.apply({
                    "attachments": attachments,
                    "fileUrl": fileUrl,
                    "options": options
                });

            }

        },
        _isFileAttachmentEnabled: function () {
            return xfalib.runtime.renderContext.mfAllowAttachments === 'true';
        },
        _isLoginAnonymous: function (value) {
            var flag;
                if(xfalib.runtime) {
                    flag = xfalib.runtime._isAnonymous;
                    if(_.isUndefined(value)) {
                        return flag;
                    }
                    xfalib.runtime._isAnonymous = value;
                    return flag;
                }
        },

        _getContextRoot: function() {
            return this.userConfig["contextPath"];
        },

        getTempPath: function() {
            return "/tmp/fd/xfaforms/" + this._getUUID();
        },
        _getFileNamePathMap: function(valueList) {
            var fileWidget = this._getFileWidgetIfPresent();
            if(fileWidget) {
                return fileWidget._getFileNamePathMap(valueList);
            }
            return {};
        },






        getMultipartData: function (data) {
            //Start multipart formatting
            var initBoundary = this.randomString();
            var strBoundary = "--" + initBoundary;
            var strMultipartBody = "";
            var strCRLF = "\r\n";

            //Create multipart for each element of the form
            for (var key in data) {
                if (data.hasOwnProperty(key)) {
                    var value = typeof data[key] == "string" ? data[key] : JSON.stringify(data[key]);
                    strMultipartBody +=
                        strBoundary
                        + strCRLF
                        + "Content-Disposition: form-data; name=\"" + key + "\""
                        + strCRLF
                        + strCRLF
                        + value
                        + strCRLF;
                }
            }
            //End the body by delimiting it
            strMultipartBody += strBoundary + "--" + strCRLF;
            //Return boundary without -- and the multipart content
            return [initBoundary, strMultipartBody];
        },

        randomString: function () {
            var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
            var string_length = 8;
            var randomString = '';
            for (var i = 0; i < string_length; i++) {
                var rnum = Math.floor(Math.random() * chars.length);
                randomString += chars.substring(rnum, rnum + 1);
            }
            return randomString;
        },

        /*
         * returns the input data in XML Form. The call is asynchronous and recieves the following options apart from the default
         * ones provided earlier
         *      validationChecker //function to call for checking validation errors received from server
         *                          The signature for the functions is
         *                              function(validations)
         *                              {
         *                                  // validations is an array of error strings.
         *                              }
         *      formState       // The state of the XFA Form, if saved by the user, otherwise the current one
         */
        getDataXML: function (options) {
            options = options || {};
            var obj = new XFAResultObject();
            if (!options.formState && !this._checkXfa(obj)) {
                options.error.call(options.context, obj);
                return;
            }
            if(!options.formState && xfalib.ut.XfaUtil.prototype.getOrElse(xfalib.runtime, "customPropertyMap.xmlOnClient", "0") === "1") {
                try {
                    var xml = this.generateDataXML();
                    obj.data = xml;
                    if (options.success) {
                        options.success.call(options.context, obj);
                    }
                } catch(exception) {
                    var msg = "Unable to generate xml on client. Use Server option to generate the xml. " + exception;
                    this._xfa.Logger.error("xfa", msg);
                    obj.completed = false;
                    obj.addMessage(2, msg, "");
                    if(options.error) {
                        options.error.apply(options.context, [obj]);
                    }
                }
                return;
            }
            var formState = options.formState || this.getFormState(true, 2).data;
            //clone the object to avoid polluting the old copy
            var params = _.extend({formDom: formState.xfaDom, requestDataXml : "true"}, formState.renderContext);
            this._invokeAtServer({
                data: params,
                dataType: 'text',
                success: function (result) {
                    obj.completed = true;
                    if (!result) {
                        obj.addMessage(0, "There was an error in getting data xml", "");
                        options.error.call(options.context, obj);
                        return;
                    }
                    obj.data = result;
                    if (options.validationChecker) {
                        if (!options.validationChecker.call(options.context, result.validationErrors)) {
                            options.error.call(options.context, obj);
                            return;
                        }
                    }
                    if (options.success)
                        options.success.call(options.context, obj,formState);
                },
                error: function (xhr, txtStatus, errorThrown) {
                    var msg = formBridge._getDataXMLError(xhr, txtStatus, errorThrown);
                    obj.completed = false;
                    obj.addMessage(2, msg, "");
                    if (options.error) {
                        options.error.call(options.context, obj);
                    }
                    if (formBridge._xfa) {
                        formBridge._xfa.host.messageBox(msg);
                    }
                }
            });
        },

        _getDataXMLError: function (xhr, txtStatus, errorThrown) {
            var msg;
            switch (xhr.status) {
                case 0:
                    msg = xfalib.locale.LogMessages["ALC-FRM-901-008"];
                    if(this._xfa) {
                        this._xfa.Logger.error("xfa", msg + " " + xhr.statusText);
                    }
                    break;
                default:
                    msg = xfalib.locale.LogMessages["ALC-FRM-901-016"];
                    if(this._xfa) {
                        this._xfa.Logger.error("xfa", msg + " " + xhr.statusText);
                    }
                    break;
            }
            return msg;

        },

        _identifyConnectionError: function (xhr, txtStatus) {
            var msg = "";
            switch (xhr.status) {
                case 0:
                    msg = xfalib.locale.LogMessages["ALC-FRM-901-008"];
                    if(this._xfa) {
                        this._xfa.Logger.error("xfa", msg + " " + xhr.statusText);
                    }
                    break;
                case 404:
                    msg = xfalib.locale.LogMessages["ALC-FRM-901-008"];
                    if(this._xfa) {
                        this._xfa.Logger.error("xfa", msg + " " + xhr.statusText);
                    }
                    break;
            }
            return msg;


        },

        _getAllowAttachmentsFromFormState: function (formState) {
            return formState.renderContext.mfAllowAttachments === 'true';
        },

        /**
         * @public
         * This performs an ajax submit to a url.
         * This API creates a form data object and submits this object.
         * @param options
         */
        doAjaxSubmit: function(options){

            if(window.FormData){

                var psuedoForm = $("<form>"),
                    formState = options.formState || this.getFormState(true, 2).data,
                    submitServiceProxyConfig = formState.additionalSubmitInformation.userConfig["submitServiceProxyConfig"],
                    action = options.action || this._getSubmitServiceProxyUrl();

                _.each(formState.additionalSubmitInformation.formAttributesData, function (value, key) {
                    psuedoForm.attr(key, value);
                }, this);

                psuedoForm.attr("action", action);
                var $charSetField = $("<input>").attr({"type": "hidden", "name": "_charset_", "value": "UTF-8"});
                $(psuedoForm).append($charSetField);

                _.each(submitServiceProxyConfig, function (fieldValue, fieldName) {
                    var newField = $("<input>").attr("type", "hidden")
                        .attr("name", fieldName)
                        .val(fieldValue);
                    $(psuedoForm).append($(newField));
                });

                //clone the object to avoid polluting the old copy
                var params = _.extend({}, formState.customPropertyMap, {formDom: formState.xfaDom}, formState.renderContext);

                for (var param in params) {
                    if (params.hasOwnProperty(param)) {
                        newField = $("<input>").attr("type", "hidden")
                            .attr("name", param)
                            .val(params[param]);

                        $(psuedoForm).append($(newField));
                    }
                }

                var fileAttachmentEnabled = formBridge._getAllowAttachmentsFromFormState(formState);
                if (fileAttachmentEnabled) {
                    if (options.fileAttachmentMap) {
                        var fileAttachmentMapInput = $("<input>").attr("type", "hidden")
                            .attr("name", "fileAttachmentMap")
                            .val(JSON.stringify(options.fileAttachmentMap));
                        $(psuedoForm).append($(fileAttachmentMapInput));
                    } else {
                        var fileAttachmentMap = formBridge._getFileNamePathMap(),
                            fileAttachmentInputs = formBridge._getFileListFromFileWidget(),
                            fileAttachmentMapInput;

                        _.each(formBridge._getCommitValueFromFileWidget(), function (nameOfFile, index) {
                            if (_.isObject(fileAttachmentInputs[index]) && _.isString(nameOfFile) && !nameOfFile.match(/\//g)) {
                                fileAttachmentInputs[index].attr("name", nameOfFile);
                                if (!fileAttachmentMap[nameOfFile]) {
                                    fileAttachmentMap[nameOfFile] = "";
                                    $(psuedoForm).append(fileAttachmentInputs[index]);
                                }
                            }
                        });
                        fileAttachmentMapInput = $("<input>").attr("type", "hidden")
                            .attr("name", "fileAttachmentMap")
                            .val(JSON.stringify(fileAttachmentMap));
                        $(psuedoForm).append($(fileAttachmentMapInput));
                    }
                }
                //the XFAResultObject that will be passed to the success and error handler
                var obj = new XFAResultObject();

                var fd = new FormData(psuedoForm[0]);
                //set contentType to false to prevent jquery from setting it to default value
                //Setting processData to false to prevent jQuery from automatically transforming the data into a query string
                // set dataType to "text" to retrieve the xml as string.
                // The ajax call returns dataXml that is passed inside XFAResultObject.
                $.ajax({
                    url: formBridge._getUrl(action),
                    data: fd,
                    processData: false,
                    dataType:'text',
                    contentType: false,
                    type: 'POST',
                    success: function (result) {
                        obj.completed = true;
                        if (!result) {
                            obj.addMessage(0, "There was an error in submitting the form", "");
                            options.error.call(options.context, obj);
                            return;
                        }
                        obj.data = result;
                        if (options.validationChecker) {
                            if (!options.validationChecker.call(options.context, result.validationErrors)) {
                                options.error.call(options.context, obj);
                                return;
                            }
                        }
                        if (options.success) {
                            options.success.call(options.context, obj);
                        }
                    },
                    error: function (xhr, txtStatus, errorThrown) {
                        var msg = formBridge._getDataXMLError(xhr, txtStatus, errorThrown);
                        obj.completed = false;
                        obj.addMessage(2, msg, "");
                        if (options.error) {
                            options.error.call(options.context, obj);
                        }
                        if (formBridge._xfa) {
                            formBridge._xfa.host.messageBox(msg);
                        }
                    }
                });

            } else {
                options.error.call(options.context);
            }
        },

        /*
         * submits the form data to a url provided in Config or Form Template
         * The API calls getDataXML, checks validation errors and either submits the data itself
         * or passes the data to the success handler provided by the caller
         *
         */
        submitForm: function (options) {
            options = options || {};
			options.error = options.error || defaultErrorHandler;
            options.context = options.context || formBridge;
            options.validationChecker = options.validationChecker || defaultValidationChecker;
            //formBridge.keyValuePairSubmission = true;

            this.uiFreeze();   // Bug: LC-6068 To show cursor in wait state and also freezing the ui by marking root subform access as readOnly.
            var originalSuccess = options.success;
            var originalError = options.error || defaultErrorHandler;
            var originalContext = options.context;
            var that = this;

            options.error = (function () {
                return function () {
                    that.uiUnFreeze();  // Bug: LC-6068 To restore cursor from wait state and also restoring the ui by marking root subform access as its old access.
                    if (originalError) {
                        originalError.apply(originalContext, arguments);
                    }
                };
            })();
            var obj = new XFAResultObject();

            // if cancelAction property is set to true in preSubmit, execPreSubmit return false
            if (this._xfa && this._xfa.form.execPreSubmit() == false ) {
                var msg = "Submit cancelled";
                this._xfa.host.messageBox(msg);
                obj.addMessage(0, msg, "xfa");
                options.error.call(options.context, obj);
                return;
            }

            if (this._xfa && this._xfa.host._validate() == false) {
                obj.addMessage(0, "client side validations failed", "xfa"); //TODO: handlesomExpression passing
                options.error.call(options.context, obj);
                return;
            } else {
                xfalib.ut.XfaUtil.prototype._triggerOnBridge("submitStart", this, "submit");
            }
            if (options.success /*|| formBridge.keyValuePairSubmission*/) {
                /*var defaultSuccessHandler = function(obj) {
                 var formState = options.formState || this.getFormState().data;
                 //clone the object to avoid polluting the old copy
                 var params = _.extend({formDom: formState.xfaDom}, formState.renderContext);

                 for(var p in params) {
                 var field = $("<input>").attr("type", "hidden").attr("name",p).val(params[p]);
                 $("#lcforms_xfaform_container").append($(field));
                 }
                 var dataField = $("<input>").attr("type", "hidden").attr("name","data").val(obj.data);
                 $("#lcforms_xfaform_container").append($(dataField));

                 var submitServiceProxyConfig = this.userConfig["submitServiceProxyConfig"];
                 var submitUrl = options.action || submitServiceProxyConfig.submitUrl;
                 $("#lcforms_xfaform_container").attr("action", submitUrl);
                 $("#lcforms_xfaform_container").submit();
                 }
                 options.success = options.success || defaultSuccessHandler*/
                //Submit from form bridge api

                options.success = (function () {
                    return function () {
                        that.uiUnFreeze();  // Bug: LC-6068 To restore cursor from wait state and also restoring the ui by marking root subform access as its old access.
                        if (originalSuccess) {
                            originalSuccess.apply(originalContext, arguments);
                        }
                    };

                })();
                formBridge.doAjaxSubmit(options);
            }
            else {
                //Always submit form state to submitServiceProxy and then the proxy will in-turn submit the data xml to the submitUrl on behalf of MobileForm
                //create a psuedo form element and do submission
                var cont = true;
                var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
                //To maintain backward compatibility
                if (!behaviorConfig.isOn('disableHeadRequest') && !behaviorConfig.isOn('mfDisableHeadRequest')) {
                    $.ajax({
                        async: false,
                        url: this._getSubmitServiceProxyUrl(),
                        type: 'HEAD',
                        complete: function (xhr, txtStatus) {
                            var msg = formBridge._identifyConnectionError(xhr, txtStatus);
                            if (msg) {
                                obj.completed = false;
                                obj.addMessage(2, msg, "");
                                if (options.error) {
                                    options.error.call(options.context, obj);
                                }
                                if (formBridge._xfa) {
                                    formBridge._xfa.host.messageBox(msg);
                                }
                                cont = false
                            }
                        }
                    });
                }

                if (cont) {
                    var action = this._getSubmitServiceProxyUrl();

                    var submitServiceProxyConfig = this.userConfig["submitServiceProxyConfig"];

                    var psuedoForm = $("<form>");

                    var formState = options.formState || this.getFormState(true, 3).data;

                    //add the additionalInformation
                    _.each(formState.additionalSubmitInformation.formAttributesData,function(value,key){
                        psuedoForm.attr(key, value);
                    },this);

                    //override action
                    psuedoForm.attr("action", action);

                    //Add _charset_ to let sling know that it should decode in UTF-8
                    var $charSetField = $("<input>").attr("type", "hidden").attr("name", "_charset_").val("UTF-8");
                    $(psuedoForm).append($charSetField);

                    behaviorConfig = this.userConfig["behaviorConfig"];

                    //add supporting fields to psuedo form
                    submitServiceProxyConfig.submitUrl = options.action || submitServiceProxyConfig.submitUrl;
                    for (var fieldName in submitServiceProxyConfig) {
                        if (submitServiceProxyConfig[fieldName]) {
                            var newField = $("<input>").attr("type", "hidden")
                                .attr("name", fieldName)
                                .val(submitServiceProxyConfig[fieldName]);

                            $(psuedoForm).append($(newField));
                        }
                    }
                    var fileAttachmentEnabled = formBridge._isFileAttachmentEnabled();
                    if (!fileAttachmentEnabled) {

                        //clone the object to avoid polluting the old copy
                        var params = _.extend({}, formState.customPropertyMap, {formDom: formState.xfaDom}, formState.renderContext);

                        for (var param in params) {
                            if (params[param]) {
                                var newField = $("<input>").attr("type", "hidden")
                                    .attr("name", param)
                                    .val(params[param]);

                                $(psuedoForm).append($(newField));
                            }
                        }

                        //for IE as you cannot submit a form without attaching it to document.
                        $("#lcforms_xfaform_container").append($(psuedoForm));
                        $(psuedoForm).submit();

                    } else {

                        var fileAttachmentMap = formBridge._getFileNamePathMap(),
                            fileAttachmentInputs = formBridge._getFileListFromFileWidget(),
                            fileAttachmentMapInput ;
                        //clone the object to avoid polluting the old copy
                        params = _.extend({}, formState.customPropertyMap, {formDom: formState.xfaDom}, formState.renderContext);

                        for (param in params) {
                            if (params[param]) {
                                var newField = $("<input>").attr("type", "hidden")
                                    .attr("name", param)
                                    .val(params[param]);

                                $(psuedoForm).append($(newField));
                            }
                        }
                        _.each(formBridge._getCommitValueFromFileWidget(), function (nameOfFile, index) {
                            if( _.isObject(fileAttachmentInputs[index]) && _.isString(nameOfFile) && !nameOfFile.match(/\//g)) {
                                fileAttachmentInputs[index].attr("name", nameOfFile);
                                if(!fileAttachmentMap[nameOfFile]) {
                                    fileAttachmentMap[nameOfFile] ="";
                                    $(psuedoForm).append(fileAttachmentInputs[index]);
                                }
                            }
                        });
                        fileAttachmentMapInput =  $("<input>").attr("type", "hidden")
                            .attr("name", "fileAttachmentMap")
                            .val(JSON.stringify(fileAttachmentMap));
                        $(psuedoForm).append($(fileAttachmentMapInput));

                        //for IE as you cannot submit a form without attaching it to document.
                        $("#lcforms_xfaform_container").append($(psuedoForm));
                        $(psuedoForm).submit();

                    }
                }
            }
            //if submit is successful, we navigate to another page so no need to call uiUnFreeze.
        },

        uiFreeze: function () {
            var $xfa_ui_freeze = $('#lcforms_xfaform_container > #xfa_ui_freeze');
            if ($xfa_ui_freeze.length > 0) {
                $xfa_ui_freeze.show()
            } else {
                $('#lcforms_xfaform_container').append('<div id="xfa_ui_freeze"></div>');
            }
        },

        uiUnFreeze: function () {
            $('#lcforms_xfaform_container > #xfa_ui_freeze').hide();
        },

        /**
         * Get all the fields in the form.
         * @param filter filter function to tell which fields to return. The
         *               function will be passed each field in the form and if
         *               it returns true the field will be returned otherwise not.
         *               **Doesn't return Master Page Fields**
         *               **Renders all pages in the process**
         * @return {Array}
         */
        getAllFields: function (filter) {
            var allFields = [];
            for (var page = 0; page < this._xfa.layout.pageCount(); page++) {
                var pageFields = this._xfa.layout.pageContent(page, "field");
                for (var i = 0; i < pageFields.length; i++) {
                    var field = pageFields.item(i);
                    if (_.isUndefined(filter) || _.isNull(filter) || filter.apply(window, [field]) === true) {
                        allFields.push(field);
                    }
                }
            }
            return allFields;
        },

        /**
         * Get the current field in focus.
         * @return {*}
         */
        getFocus: function () {
            if (this._xfa.host.getFocus) {
                var obj = this._xfa.host.getFocus();
                if (obj)
                    return this._xfa.host.getFocus().somExpression;
                return null;
            }
            else
                return "unsupported";
        },

        /*
         * Validate the form.
         * Run client side validations.
         *
         *
         */
        validateForm: function (options) {
            options = options || {};
            options.error = options.error || defaultErrorHandler;
            options.context = options.context || this;
            var valMessages = [];
            var validationsValue = this._xfa.host._validate({
                valMessages: valMessages
            });

            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                throw obj.getNextMessage().message;

            if (validationsValue == false) {
                obj.addMessage(0, "client side validations failed", "xfa");
                _.each(
                    _.filter(valMessages, function (msg) {
                        return msg.severity === "error"
                    }),
                    function (msg) {
                       obj.addMessage(1, msg.message, msg.ref)
                    }
                );
                options.error.call(options.context, obj);
            }
            else if (options.success)
                options.success.call(options.context, obj);

            return validationsValue;
        },
        //--checking for browser compatibility
        _isBrowserCompatible: function () {
            var isWin = false;
            var isMac = false;
            var isiPad = false;
            var isAndroid = false;
            var isWebKit = false;
            if (navigator.appVersion.indexOf("Win") != -1)
                isWin = true;
            else if (navigator.appVersion.indexOf("Mac") != -1)
                isMac = true;
            else if (navigator.userAgent.match(/iPad/i) != null)
                isiPad = true;
            else if (navigator.userAgent.toLowerCase().indexOf("android") > -1)
                isAndroid = true;
            if (navigator.userAgent.toLowerCase().indexOf("webkit") > -1)
                isWebKit = true;

            var browserVersion = parseInt($.browser.version, 10);
            if (isWin && ($.browser.msie && (browserVersion == 6 || browserVersion == 7 || browserVersion == 8)))
                return false;
            else if (isWin && (isWebKit || $.browser.mozilla || ($.browser.msie && (browserVersion == 9 || browserVersion == 10)))) {
                return true;
            }
            else if ((isMac || isiPad || isAndroid) && isWebKit) {
                return true;
            }
            else {
                return false;
            }
        },
        /*
         * Restores the Form State to a previous state. This is a Asynchronous call and recieves a formState from the
         * caller. The state will be applied and success or error handlers will be called after the operation is
         * completed.
         */
        restoreFormState: function (options) {
            if (window.atob && options.base64FormState !== undefined) {
                // Decode base 64 encoded string to form the form DOM object.
                var utftext = atob(options.base64FormState),
                    string = "",
                    i = 0,
                    c = 0,
                    c1 = 0,
                    c2 = 0,
                    c3 = 0;
                while ( i < utftext.length ) {
                    c = utftext.charCodeAt(i);
                    if (c < 128) {
                        string += String.fromCharCode(c);
                        i++;
                    }
                    else if((c > 191) && (c < 224)) {
                        c2 = utftext.charCodeAt(i+1);
                        string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                        i += 2;
                    }
                    else {
                        c2 = utftext.charCodeAt(i+1);
                        c3 = utftext.charCodeAt(i+2);
                        string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                        i += 3;
                    }
                }
                utftext = string;
                var formDom = JSON.parse(utftext);
                options.formState = formDom;
            }

            /*
             * We have to merge the runtime renderContext with the renderContext of the formState passed
             * so that no custom properties that were set in the context(present in the form state) are ignored.
             */
            xfalib.runtime.renderContext = xfalib.runtime.renderContext || {};
            _.extend(xfalib.runtime.renderContext, options.formState.renderContext);
            if (!this._xfa) {
                this.storage = {};
                this.storage.formState = options.formState;
                this.storage.error = options.error;
                this.storage.success = options.success;
                this.storage.context = options.context;
            } else {
                this._xfa.host.playJson(JSON.parse(options.formState.xfaDom));
                this.customContextProperty(options.formState.customPropertyMap);
                if(_.isFunction(options.success)) {
                    options.success.call(this);
                }
            }
        },
        customContextProperty: function(property,value) {
            var customPropertyMap = xfalib.runtime.customPropertyMap || {};
            if(_.isUndefined(value)) {
                if(_.isObject(property)) {
                    _.extend(customPropertyMap, property);
                    xfalib.runtime.customPropertyMap=customPropertyMap;
                } else {
                return customPropertyMap[property];
                }
            } else {
                var oldValue = customPropertyMap[property];
                customPropertyMap[property]=encodeURIComponent(value);
                xfalib.runtime.customPropertyMap=customPropertyMap;
                return oldValue;
            }
        },
        /*
         * @private
         */
        _getStorage: function () {
            var s = null;
            if (this.storage) {
                var s = this.storage.formState
                this.storage.formState = null;
            }
            return s;
        },

        _getXmlStorage: function () {
            var s = null;
            if (this.xmlStorage) {
                var s = this.xmlStorage.xmlDocument;
                this.xmlStorage.xmlDocument = null;
            }
            return s;
        },

        /*
         * @private
         */
        _getHTMLElement: function (somExpression, full) {
            var obj = this._getHTMLElementInternal(somExpression, full,this._formDoc);
            return obj;
        },

        _getHTMLElementInternal: function(somExpression, full,referenceDocument){
            somExpression = full === true ? somExpression : "xfa[0].form[0]." + somExpression;
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                return obj;
            var elem = this._xfa.resolveNode(somExpression);
            if (_.isEmpty(elem)){
                obj.addMessage(0, somExpression + " not found", somExpression);
            } else {
                var elemId = xfalib.ut.XfaUtil.prototype.jqId(elem.htmlId);
                $(elemId, referenceDocument).children();
                switch (elem.className) {
                    case "instanceManager":
                        obj.addMessage(0, "No HTML Element exists for instanceManagers", somExpression);
                        break;
                    case "subform":
                        obj.data = {elem: $(elemId, referenceDocument)[0]}
                        break;
                    case "field":
                        var data = $(elemId, referenceDocument);
                        var child = data.children();

                        obj.data = {
                            elem: data[0],
                            caption: child[0],
                            widget: { elem: child[1],
                                child: $("input,select", child[1])[0]
                            }
                        };
                        if (!obj.data.widget) {
                            obj.data.widget = {
                                elem: child[0],
                                child: $("input,select", child[0]) [0]
                            }
                        }
                        break;
                    default:
                        obj.data = {elem: $(elemId, referenceDocument)[0]};
                        break;
                }
            }
            return obj;
        },

        _postExternalMessage: function (message) {
            if (this.userConfig["postExternalMessageConfig"] && _.isFunction(this.userConfig["postExternalMessageConfig"]["postExternalHandler"])) {
                var externalHandler = this.userConfig["postExternalMessageConfig"]["postExternalHandler"];
                externalHandler(message);
            }
        },

        scaleForm: function (viewportWidth) {
            if (viewportWidth) {
                this.userConfig["viewportWidth"] = viewportWidth;
                window.xfaViewRegistry.scaleForm();
            }
        },

        /**
         * This function hides the toolbar where required.
         * @memberof FormBridge
         */
        hideToolbar: function(){
          $(".toolbarheader").hide();
        },

        /**
         * Used to Register an event listener for specific Form Bridge Event.
         * @param eventName {string} name of the event for which listener has to be added. It must be one of the events
         * mentioned in the documentation.
         * @param handler {function} event listener which is called when the event is triggered.
         * @param [context] {object} context is used as the <i>this</i> object inside handler function
         */

        on: function (eventName, handler, context) {
            this._$target.on(eventName, handler, context);
        },


        /**
         * Unregister the event registered using the {@link FormBridge.on|on} function
         *
         * @param eventName {string} name of the event to un-register.
         * @param [selector] {string} selector which should match the one originally passed to FormBridge's on() while registering handlers
         * @param [handler] {function} handler which needs to un-registered. If not provided all the event listeners
         * will be unregistered
         */

        off: function (eventName, selector, handler) {
            this._$target.off(eventName, selector, handler);
        },

        /**
         * Internal API
         *
         * @private
         */

        trigger: function (eventName, extraParamerts) {
            if(this.isAnalyticsEnabled || eventName == xfalib.template.Constants.scribbleChangeEvent) {
                this._$target.trigger(eventName, extraParamerts);
            }
        },

        /**
         * constructs the dataSomMap and returns that. If a valid object is provided as the first argument then it
         * modifies and adds entries in that map only, otherwise constructs a new map.
         * @param map {object}
         * @returns {XFAResultObject} with the data parameter as the dataSomMap
         */
        getDataSomMap: function (map) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj)) {
                return obj;
            }
            var _map = map;
            if(!_.isObject(map)) {
                _map = {};
            }
            _map = this._xfa.form._getDataSomMap(_map);
            obj.data = _map;
            return obj;
        },

        /**
         * Updates the field values with the values provided in the map. If map is not an object, returns an error.
         * @param map {object}
         * @return {XFAResultObject} with the data parameter as null.
         */
        restoreDataSomMap: function (map) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj)) {
                return obj;
            }
            if(!_.isObject(map)) {
                obj.addMessage(0, "Invalid Argument passed. First argument has to be an object", null);
                return obj;
            }
            this._xfa.form._restoreDataSomMap(map);
            obj.data = null;
            return obj;
        },

        /**
         * Namespace resolver needed for xpath resolution. We need to add more namepsaces
         * @param prefix
         * @returns {*|null}
         */
        nsResolver : function (prefix) {
            var ns = {
                'xfa' : 'http://www.xfa.org/schema/xfa-data/1.0/',
                'xdp' : 'http://ns.adobe.com/xdp/'
            };
            return ns[prefix] || null;
        },

        /**
         * merges the Form with the xmlDocument provided
         * @param options {object} with the folllowing syntax
         *  {
         *   xmlDocument
         *   success: function() {}
         *   error: function(xfaResultObject) {}
         *   context:
         *  }
         * @return {XFAResultObject} with the data parameter as null.
         */
        playDataXML: function(options) {
            if (!this._xfa) {
                this.xmlStorage = {};
                this.xmlStorage.xmlDocument = options.xmlDocument;
                this.xmlStorage.error = options.error || defaultErrorHandler;
                this.xmlStorage.success = options.success;
                this.xmlStorage.context = options.context;
            } else {
                var obj = new XFAResultObject(),
                    options = options || {},
                    error = options.error || defaultErrorHandler,
                    success = options.success,
                    xmlDocument = options.xmlDocument,
                    rootElement;
                if(xmlDocument == null) {
                    obj.addMessage(0, "Invalid Argument Error. XML Document is not defined", null);
                    error.apply(options.context, [obj]);
                    return;
                }
                if(_.isString(xmlDocument)) {
                    this._xfa.Logger.info("xfa", "xmlDocument is of type string. converting it to document");
                    try {
                        xmlDocument = $.parseXML(xmlDocument);
                    } catch(e) {
                        obj.addMessage(2, "Unable to parse Data XML " + e, null);
                        error.apply(options.context, [obj]);
                        return;
                    }
                }
                if(!(xmlDocument instanceof Document) && !(xmlDocument instanceof Element)) {
                    obj.addMessage(1, "Invalid Argument Error. XML Document is not an instance of Document or Element", null);
                    error.apply(options.context, [obj]);
                    return;
                }
                try {
                    this._xfa.host.playDataXml(xmlDocument);
                } catch(e) {
                    obj.addMessage(2, "Unexpected Exception: Unable to play Data XML " + e, null);
                    error.apply(options.context, [obj]);
                }
                if(success) {
                    success.apply(options.context,[obj]);
                }
            }
        },

        /**
         * Returns Data XML of the Form. If dataXML is passed, it is merged with
         * the Data XML.
         * @returns {string|Node} If dataXML input is String, it returns string, otherwise
         *                        dataXML is updated and returned
         *                        Returns null in case it fails to generate data xml.
         * @param bGenerateXDPRoot whether to generate the xdp root if it doesn't exists
         * @param dataXML {Element|Document|String} If dataXML passed is document or Element, it updates that and
         * returns it. In case of string a new string is returned.
         */
        generateDataXML: function (dataXML, bGenerateXDPRoot) {
            if(_.isUndefined(document.evaluate)) {
                // need to do it here since XPathResult is also undefined in IE
                wgxpath.install();
            }
            try {
                var prefillXML = dataXML || xfalib.runtime.renderContext.data,
                    rootSubform = this._xfa.form._getRootSubform(),
                    bAddXDPRoot = !(bGenerateXDPRoot === false),
                    impl, xmlDoc, xdpElement, datasets, data, rootNode, xPathResult, newXmlDoc;
                if (prefillXML == null) {
                    impl    = document.implementation;
                    xmlDoc  = impl.createDocument ('http://ns.adobe.com/xdp/', 'xdp:xdp', null);
                    datasets = xmlDoc.createElementNS("http://www.xfa.org/schema/xfa-data/1.0/", "xfa:datasets");
                    data = xmlDoc.createElement("xfa:data");
                    rootNode = xmlDoc.createElement(rootSubform.getAttribute("name"));
                    data.appendChild(rootNode);
                    datasets.appendChild(data);
                    xmlDoc.documentElement.appendChild(datasets);
                } else {
                    xmlDoc = prefillXML;
                    if(_.isString(xmlDoc)) {
                        this._xfa.Logger.info("xfa", "xmlDocument is of type string. converting it to document")
                        xmlDoc = $.parseXML(xmlDoc);
                    }
                    rootNode = xfalib.ut.XMLUtils.getXFARootFormElementFromXML(xmlDoc);
                    var xmlDocElement = xmlDoc instanceof Element ? xmlDoc : xmlDoc.documentElement;
                    if (bAddXDPRoot && xmlDocElement.nodeName !== "xdp:xdp") {
                        impl    = document.implementation;
                        xmlDoc  = impl.createDocument ('http://ns.adobe.com/xdp/', 'xdp:xdp', null);
                        datasets = xmlDoc.createElementNS("http://www.xfa.org/schema/xfa-data/1.0/", "xfa:datasets");
                        data = xmlDoc.createElement("xfa:data");
                        rootNode = xmlDoc.importNode(rootNode, true);
                        data.appendChild(rootNode);
                        datasets.appendChild(data);
                        xmlDoc.documentElement.appendChild(datasets);
                    }
                }
                rootSubform.generateDataXML(rootNode, rootNode);
                if(prefillXML == null || _.isString(prefillXML)) {
                    return new XMLSerializer().serializeToString(xmlDoc.documentElement);
                } else {
                    return xmlDoc;
                }
            } catch(e) {
                this._xfa.Logger.error("xfa", "Error in Generating Data XML on Client " + e);
                return null;
            }
        },

        /**
         * Destroy Mobile Form so that another form can be rendered. if bFull parameter
         * is passed as true, then all the scripts are destroyed as well.
         * @param bFull
         */
        destroyForm: function (bFull) {
            $("#mfstyle").remove();
            var oldMap = xfalib.runtime.customPropertyMap;
            // In adaptive form, we never use the view layer of mobile forms, hence adding null check
            if(xfaViewRegistry != null) {
                xfaViewRegistry.rootSubformView = null;
                xfaViewRegistry.clearTemplateCache();
                xfaViewRegistry.resetLayoutManager();
            }
            xfalib.runtime = {
                xfa: null,
                app: null,
                Document: null,
                form: null,
                renderContext: null,
                _private: {},
                customPropertyMap: oldMap
            };
            if(xfalib.runtime.console) {
                xfalib.runtime.console = undefined;
            }
            this._xfa = null;
            xfalib.script.Xfa.Instance = null;
            $(window).trigger("destroy.xfa");
            $(window).off(".xfa");
            xfalib.view.util.TextMetrics._destroy();
            xfalib.view.util.traversalManager._destroy();
            xfalib.view.FieldView.prototype._clearFocusInfo();
            if(bFull === true) {
                $(window).off();
                $("body").empty();
                //this is added by FileAttachment. It should have been
                // a namespace event
                $(document).off("mousedown");
                _.each(xfalib, function (obj, key) {
                   xfalib[key] = undefined;
                });
                xfalib = null;
                wgxpath = undefined;
                FormCalc = undefined;
                // In adaptive form, we never use the view layer of mobile forms, hence adding null check
                if(xfaViewRegistry != null) {
                    xfaViewRegistry.destroy();
                    xfaViewRegistry = undefined;
                }
                $.Widget = undefined;
                $.widget = undefined;
                $.xfaWidget = undefined;
                $.fn = undefined;
                $.prototype.abstractWidget = undefined;
                $.prototype.adobeDateTimePicker = undefined;
                $.prototype.adobeFileAttachment = undefined;
                $.prototype.adobeFileUploader = undefined;
                $.prototype.dateTimeEdit = undefined;
                $.prototype.dropDownList = undefined;
                $.prototype.defaultWidget = undefined;
                $.prototype.fileUpload = undefined;
                $.prototype.imageField = undefined;
                $.prototype.listBox = undefined;
                $.prototype.nwkListBox = undefined;
                $.prototype.numericInput = undefined;
                $.prototype.signatureField = undefined;
                $.prototype.ScribbleImageField = undefined;
                $.prototype.textField = undefined;
                $.prototype.xfaButton = undefined;
                $.prototype.XfaCheckBox = undefined;
                $.expr = undefined;
                window.formBridge = undefined;
                FormBridge = undefined;
                window.renderNextPage = undefined;
                window.handleFooterLogic = undefined;
                window.handleScroll = undefined;
                optionsFromProfileNode = undefined;
                options = undefined;
                FD = undefined;
                window._ = undefined;
                $plugFileWidgetDom = undefined;
            }
        }
    });

    window.formBridge = new FormBridge();
    window.formBridge._$target = $(window.formBridge);
    try {
        var evnt = document.createEvent("CustomEvent");
        evnt.initCustomEvent("FormBridgeInitialized", true, true, {"formBridge": window.formBridge});
        window.dispatchEvent(evnt);
    }

    catch (exception) {
        // written for env rhino to execute(for server side validation)
    }

    if (!window.formBridge.userConfig["postExternalMessageConfig"]) {
        if (window !== window.parent) {
            try {
                window.parent.document.getElementById(window.name);
                //We are here means no cross domain issue. So if user has not defined custom postExternalMessageConfig and
                // then we'll create one which would just send event on parent.
                window.formBridge.registerConfig("postExternalMessageConfig", {
                    "postExternalHandler": function (message) {
                        var tmpEvent = document.createEvent("CustomEvent");
                        tmpEvent.initCustomEvent(message.name, true, true, message.data);
                        window.parent.dispatchEvent(tmpEvent);
                    }
                });
            } catch (e) {
                //ignore the error
            }
        }
    }
    window.formBridge._postExternalMessage({
        name: "FormBridgeInitialized",
        data: {
            "formBridge": window.formBridge
        }
    });
})($);

/**
 * This should house all the internal APIs added tp FormBridge
 * Created by sasdutta on 12/23/2014.
 */

(function ($, _, formBridge) {
    formBridge.internal = {

        /**
         * Get SOM expressions of all the fields in the form, including master page fields
         *
         * @return {Array} of som expressions as strings.
         */
        getAllFieldsSom: function () {
            var fieldsSom = [];
            function getAllFieldsSomVisitor(target) {
                if (target instanceof xfalib.script.Field) {
                    fieldsSom.push(target.somExpression);
                }
            }

            formBridge._xfa.form._getRootSubform()._visitAllmoChildren(getAllFieldsSomVisitor);
            return fieldsSom;
        },

        /**
         * @param pageNum {int} scroll to specified pg no if available
         * @returns nothing
         * @private
         */
        scrollToPage: function (pageNum) {
            if (pageNum > 0 && pageNum <= formBridge.pagingManager().pageCount()) {
                formBridge.pagingManager()._makePage(pageNum);

                var $targetPg = $("#lcforms_xfaform_container .page").eq(pageNum - 1); // zero based index in JQ

                setTimeout(function () {
                    $(window).scrollTop($targetPg.offset().top); // newly added pages need time to render
                });
            }
        },

        resolveNode: function (somExpression) {
            return formBridge._xfa.resolveNode(somExpression);
        },

        pageCount: function () {
            return formBridge.pagingManager().pageCount();
        },

        page: function (fieldNode) {
            return formBridge._xfa.$layout.page(fieldNode);
        },

        normalizeSom: function (som) {
            // adding index and prefix to the som expression as obtained from designer
            if(!_.isString(som)) {
                return null;
            }
            som = som.replace(/\s/g, '');
            var xfaPrefix = "xfa[0].form[0].",
                normalizedSom = (som + ".").replace(/(\])?\./g, function ($0, $1) { return $1 ? $0 : '[0].'; }).slice(0, -1);

            if(normalizedSom.slice(0,xfaPrefix.length) !== xfaPrefix) {
                normalizedSom = xfaPrefix + normalizedSom;
            }
            return normalizedSom;
        }
    };
}($, _, window.formBridge));

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

/**
 * This object hosts FormCalc build-in functions
 */
FormCalc = function(){};


FormCalc.convertArgumentsToArray = function() {
    var args= [];
    for (var i = 0;i<arguments.length;i++) {
        if(arguments[i] instanceof Array) {
            args = args.concat(arguments[i])
        }
        else {
            args.push(arguments[i])
        }
    }
    return args;
}

////Arithmetic Built-in Functions
/**
 * Returns the average of the non-null elements of a given set of numbers.
 */
FormCalc.avg = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
	return FormCalc.runWithNumericArgs(function(){
        var sum = 0 ;
        var valid_count = 0;
        for(var idx=0; idx<arguments.length; idx++ ){
        		sum += arguments[idx];
        		valid_count++;
        }
        return valid_count ? sum/valid_count :null;
	}, args);
};

/**
 * Returns the count of the non-null elements of a given set of numbers.
 */
FormCalc.count = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
    var argus = FormCalc.limitAllNullArgs(args);
	return argus.length ? argus.length : 0
};

/**
 * Returns the max of the non-null elements of a given set of numbers.
 */
FormCalc.max = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
    return FormCalc.runWithNumericArgs(Math.max, args);
};

/**
 * Returns the min of the non-null elements of a given set of numbers.
 */
FormCalc.min = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
    return FormCalc.runWithNumericArgs(Math.min, args);
};

/**
 * Returns the modulus of one number divided by another..
 */
FormCalc.mod = function(a,b){
	if(b==0 ){
		throw "<missing or illegal parameter(s).>";
	}
	return a%b;
};

/**
 * Returns the sum of the non-null elements of a given set of numbers.
 */
FormCalc.sum = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
    return FormCalc.runWithNumericArgs(function(){
    	var result = 0;
        for(var idx=0;idx<arguments.length;idx++ ){
        	result += arguments[idx];
        }
        return result;
	}, args);
};

/**
 * Returns a number rounded to a given number of decimal places
 */
FormCalc.round = function(n1,n2){
	if(!FormCalc.isNumeric(n1)){
		return 0;
	}
	if(arguments.length == 1) {
        return Math.round(n1);
    }else if(arguments.length == 2){
    	if(n2==null){
    		return null;
    	}
    	
    	n1 = parseFloat(n1);
    	if(n2 > 12){
    		n2 = 12;
    	}
    	if(isNaN(n1) || !isFinite(n1)){
    		return n1;
    	}else{
    		return n1.toFixed(n2);    		
    	}	
    }
};

/**
 * Returns the radian value of a given number.
 */
FormCalc.deg2Rad = function(angle){
	return FormCalc.isNumeric(angle) ? (angle / 180) * Math.PI :null;
};

/**
 * Returns the degree value of a given number.
 */
FormCalc.rad2Deg = function(radio){
	return FormCalc.isNumeric(radio) ? radio * 180 / Math.PI : null;	
};
////String Built-in Functions 
/**
 * Locates the starting character position of string s2 within string s1.
 */
FormCalc.at = function(n1,n2){
	return n1.indexOf(n2) + 1;
};

/**
 * Returns the string concatenation of a given set of strings.
 */
FormCalc.concat = function(){
	var sArray = new Array();
	for(var i=0;i<arguments.length;i++){
		if(arguments[i]!=null){
			sArray[sArray.length] = arguments[i].toString();
		}
	}

	if(sArray.length == 0){
		return null;
	}else{
		return sArray.join("");
	}
};

/**
 * Extracts a number of characters from a given string, 
 * starting with the first character on the left.
 */
FormCalc.left = function(s,n){
	if(s==null){
		return null;
	}
	return s.substring(0,n);
};

/**
 * Extracts a number of characters from a given string, 
 * beginning with the last character on theright.
 */

FormCalc.right = function(s,n){
	if(s==null){
		return null;
	}
	return s.substring(s.length-n,s.length);
};

/**
 * Returns the number of characters in a given string.
 */
FormCalc.len = function(s){
	if(s==null){
		return 0;
	}else{
		return s.toString().length;		
	}
};

/**
 * Returns a string with all leading white space characters removed.
 */
FormCalc.ltrim = function(s){
	if(s==null){
		return null;
	}
	return s.replace(/^\s+/,"");
};

/**
 * Returns a string with all trailing white space characters removed.
 */
FormCalc.rtrim = function(s){
	if(s == null){
		return null;
	}
	return s.replace(/\s+$/,"");
};

/**
 * Replaces all occurrences of one string with another within a given string.
 */
FormCalc.replace = function(s1, s2, s3) {
	if(s1 == null){
		return null;
	}
	if (undefined == s3) {
		s3 = "";
	}
	return s1.replace(s2, s3);
};

/**
 * returns a string consisting of a given number of blank spaces.
 */
FormCalc.space = function(n){
	var sArray = new Array();
	var num = Math.floor(n);
	for(var i=0;i<num;i++){
		sArray[sArray.length]=" ";
	}
	return sArray.join("");
};

/**
 * Extracts a portion of a given string.
 * 
 */
FormCalc.substr = function(s1,n1,n2){
    if(n2<=0){
    	return "";
    }
    if(n1 < 1){
    	n1 = 1;
    } else if(n1 > s1.length){
    	n1 = s1.length;
    }
	return s1.substring(n1-1,n1-1+n2);
};

/**
 * Inserts a string into another string.
 * 
 */
FormCalc.stuff = function(s1, n1, n2, s2){
    if(n2<0){
    	n2=0;
    }
    if(n1 < 1){
    	n1 = 1;
    } else if(n1 > s1.length){
    	n1 = s1.length;
    }
    if(s2 == undefined){
    	s2="";
    }
	return s1.substring(0, n1-1) + s2 + s1.substring(n1 + n2-1,s1.length);
};

/**
 * Returns a string where all given uppercase characters are converted to lowercase.
 */
FormCalc.lower = function(s1){
	if(s1==null){
		return null;
	}else{
		return s1.toLowerCase();		
	}
};

/**
 * Returns a string with all given lowercase characters converted to uppercase.
 */
FormCalc.upper = function(s1){
	if(s1==null){
		return null;
	}else{
		return s1.toUpperCase();		
	}
};

/**
 * Selects a value from a given set of parameters.
 */
FormCalc.choose = function(n1,s1){
	if(n1 < 1){
		return "";
	}
	if(n1 < arguments.length){
		return arguments[n1];
	} else {
		return "";
	}
};
	
/**
 * Returns true if a value is in a given set.
 */
FormCalc.oneof = function(s1, s2){
	for(var idx = 1; idx < arguments.length; idx++){
		if(s1 == arguments[idx]){
			return true;
		}
	}
	return false;
};

/**
 * This logical function returns true if a value is within a given range.
 */
FormCalc.within = function(s1, s2, s3){
	return (s1>=s2 && s1<=s3);
}

/**
 * 
 */
FormCalc.iffun = function(s1, s2, s3){
	FormCalc.checkMinArgs(arguments.length, 2);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if(s1){
		return s2;
	}else{
		return s3;
	}
};


/**
 * Returns the annual percentage rate for a loan.
 */
FormCalc.apr = function(nPrincipal, nPayment, nPeriods) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if (nPrincipal <= 0 || nPayment <= 0 || nPeriods < 0) {
		throw "<missing or illegal parameter(s).>";
	}
	
	var maxIterations = 500;
	var eps = 0.005;
	var delta = 0.0000001;
	var nInterest = 0.05;
	var nPmtZero = nPrincipal / nPeriods;
	var nPmtCur = FormCalc.loanPmt(nPrincipal, nInterest, nPeriods);
	var i = 1;

	do {
		if (Math.abs(nPmtCur - nPmtZero) < delta)
			break;
		nInterest *= (nPayment - nPmtZero) / (nPmtCur - nPmtZero);
		nPmtCur = FormCalc.loanPmt(nPrincipal, nInterest, nPeriods);
	} while (!(++i > maxIterations || Math.abs(nPayment - nPmtCur) < eps));
	var nRate = (Math.abs(nPmtCur - nPmtZero) < delta) ? 0 : 12 * nInterest;
	return FormCalc.checkResult(nRate);
};

/**
 * Returns the number of periods needed for an investment earning a fixed, but compounded,
 * interest rate to grow to a future value.
 */
FormCalc.cterm = function(nInterest, nFuture, nPresent) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if (nInterest <= 0 || nFuture <= 0 || nPresent < 0) {
		throw "<missing or illegal parameter(s).>";
	}
	var nPeriods = Math.log(nFuture / nPresent) / Math.log(1 + nInterest);
	return FormCalc.checkResult(nPeriods);
};

/**
 * Returns the future value of periodic constant payments at a constant interest rate.
 */
FormCalc.fv = function(nPayment, nInterest, pnPeriods) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	var nPeriods = parseInt(pnPeriods);
	if (nPeriods <= 0 || nPayment <= 0 || nInterest < 0) {
		throw "<missing or illegal parameter(s).>";
	}

	var nVal;
	if (nInterest == 0) {
		nVal = nPayment * nPeriods;
	} else {
		nVal = nPayment * (1 + nInterest)
				* (FormCalc.intRate(nInterest, nPeriods - 1) - 1) / nInterest + nPayment;
	}

	return FormCalc.checkResult(nVal);
};

/**
 * Returns the amount of interest paid on a loan over a period of time.
 *
 */
FormCalc.ipmt = function(nPrincipal, nInterest, nPayment, nStart, nMonths) {
	FormCalc.checkMinArgs(arguments.length, 5);
	FormCalc.checkMaxArgs(arguments.length, 5);
    if(nPrincipal <=0 || nInterest <=0 ||nPayment <=0  ||nStart<1 ||nMonths<1){
    	throw "<missing or illegal parameter(s).>";
    }
	
	nInterest /= 12;
	nStart = parseFloat(nStart);
	nMonths = parseFloat(nMonths);
	if (nPayment <= nPrincipal * nInterest) {
		return 0;
	} else if (nMonths + nStart - 1 > FormCalc.loanTerm(nPrincipal, nInterest, nPayment)) {
		return 0;
	} else {
		var nPrincipalRemaining = nPrincipal;
		var nPrincipalPaidInPeriod = 0;
		var nInterestPaidInPeriod = 0;
		for ( var i = 1; i < nStart; i++) {
			nInterestPaidInPeriod = nPrincipalRemaining * nInterest;
			nPrincipalPaidInPeriod = nPayment - nInterestPaidInPeriod;
			nPrincipalRemaining -= nPrincipalPaidInPeriod;
			if (nPrincipalRemaining <= 0)
				break;
		}
		var nInterestPaid = 0.;
		for ( var i = nStart; i < nStart + nMonths; i++) {
			nInterestPaidInPeriod = nPrincipalRemaining * nInterest;
			nPrincipalPaidInPeriod = nPayment - nInterestPaidInPeriod;
			nPrincipalRemaining -= nPrincipalPaidInPeriod;
			nInterestPaid += nInterestPaidInPeriod;
			if (nPrincipalRemaining <= 0)
				break;
		}
		return FormCalc.checkResult(nInterestPaid);
	}
};

/**
 * Returns the net present value of an investment based on a discount rate, and a series of
 * periodic future cash flows.
 *
 */
FormCalc.npv = function(){
	FormCalc.checkMinArgs(arguments.length, 1);

	var nDiscountRate = FormCalc.parseFloat(arguments[0]);
    if(nDiscountRate<=0){
    	throw "<missing or illegal parameter(s).>";
    }	
	
	var nVal = 0;
	var nDenom = 1;
	for ( var i = 1; i < arguments.length; i++) {
		if(null == arguments[i]){
			return null;
		}
		nDenom *= (1 + nDiscountRate);
		nVal += FormCalc.parseFloat(arguments[i]) / nDenom;
	}
	return FormCalc.checkResult(nVal);

};

/**
 * Returns the payment for a loan based on constant payments and a constant interest rate.
 */
FormCalc.pmt = function(nPrincipal, nInterest, nPeriods) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if(nPrincipal <=0 || nInterest<=0 || nPeriods <=0){
    	throw "<missing or illegal parameter(s).>";
    }
	var nPayment = FormCalc.loanPmt(parseFloat(nPrincipal), parseFloat(nInterest),
			parseInt(nPeriods));
	return FormCalc.checkResult(nPayment);

};

/**
 * Returns the amount of principal paid on a loan over a period of time.
 * 
 */
FormCalc.ppmt = function(nPrincipal, nInterest, nPayment, nStart, nMonths) {
	FormCalc.checkMinArgs(arguments.length, 5);
	FormCalc.checkMaxArgs(arguments.length, 5);
    if(nPrincipal <=0 || nInterest <=0 ||nPayment <=0  ||nStart<1 ||nMonths<1){
    	throw "<missing or illegal parameter(s).>";
    }
	
	nPrincipal = parseFloat(nPrincipal);
	nInterest = parseFloat(nInterest);
	nPayment = parseFloat(nPayment);
	nStart = parseInt(nStart);
	nMonths = parseInt(nMonths);

	nInterest /= 12;
	if (nPayment <= nPrincipal * nInterest) {
		return 0;
	} else if (nMonths + nStart - 1 > FormCalc.loanTerm(nPrincipal, nInterest, nPayment)) {
		return 0;
	} else {
		var nPrincipalRemaining = nPrincipal;
		var nPrincipalPaidInPeriod = 0;
		var nInterestPaidInPeriod = 0;
		for ( var i = 1; i < nStart; i++) {
			nInterestPaidInPeriod = nPrincipalRemaining * nInterest;
			nPrincipalPaidInPeriod = nPayment - nInterestPaidInPeriod;
			nPrincipalRemaining -= nPrincipalPaidInPeriod;
			if (nPrincipalRemaining <= 0)
				break;
		}
		var nPrinciplePaid = 0;
		for ( var i = nStart; i < nStart + nMonths; i++) {
			nInterestPaidInPeriod = nPrincipalRemaining * nInterest;
			nPrincipalPaidInPeriod = nPayment - nInterestPaidInPeriod;
			nPrincipalRemaining -= nPrincipalPaidInPeriod;
			nPrinciplePaid += nPrincipalPaidInPeriod;
			if (nPrincipalRemaining <= 0)
				break;
		}
		return FormCalc.checkResult(nPrinciplePaid);
	}
};

/**
 * Returns the present value of an investment of periodic constant payments at a constant 
 * interest rate.
 *
 */
FormCalc.pv = function(nPayment, nInterest, nPeriods) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if (nPayment <= 0 || nPeriods <= 0 ) {
		throw "<missing or illegal parameter(s).>";
	}
	if(nPayment==null || nInterest==null){
		return null;
	}
	var nPayment = parseFloat(nPayment);
	var nInterest = parseFloat(nInterest);
	var nPeriods = parseInt(nPeriods);

	var nVal;
	if (nInterest == 0) {
		nVal = nPayment * nPeriods;
	} else {
		nVal = nPayment * (1 - 1 / FormCalc.intRate(nInterest, nPeriods)) / nInterest;
	}
	return FormCalc.checkResult(nVal);
};

/**
 * Returns the compound interest rate per period required for an investment to grow from
 * present to future value in a given period.
 * 
 */
FormCalc.rate = function(nFuture, nPresent, nPeriods) {
	if (nFuture <= 0. || nPresent <= 0. || nPeriods <= 0) {
		throw "<missing or illegal parameter(s).>";
	}

	var nFuture = parseFloat(nFuture);
	var nPresent = parseFloat(nPresent);
	var nPeriods = parseInt(nPeriods);

	var nRate = Math.exp(Math.log(nFuture / nPresent) / nPeriods) - 1;
	return FormCalc.checkResult(nRate);
};

/*
 * Term This function returns the number of periods needed for an investment
 * earning a fixed, but compounded interest rate to grow to a future value.
 */
FormCalc.term = function(nPayment, nInterest, nFuture) {
	var nPayment = FormCalc.parseFloatOrThrowError(nPayment);
	var nInterest = FormCalc.parseFloatOrThrowError(nInterest);
	var nFuture = FormCalc.parseFloatOrThrowError(nFuture);

	if (nPayment <= 0. || nInterest <= 0. || nFuture <= 0.) {
		throw "<missing or illegal parameter(s).>";
	}
	
	var nPeriods;
	if (nFuture <= nPayment) {
		nPeriods = 1;
	} else {
		nPeriods = Math.log((nFuture - nPayment) / nPayment * nInterest
				+ (1 + nInterest))
				/ Math.log(1 + nInterest);
	}
	return FormCalc.checkResult(nPeriods);
};

FormCalc.loanTerm = function(nPrincipal, nInterest, nPayment) {
	var nRemaining = nPrincipal;
	var nMonths = 0;
	while (nRemaining > 0.0) {
		nRemaining = nRemaining - nPayment + nRemaining * nInterest;
		nMonths++;
	}
	return FormCalc.checkResult(nMonths);
};
/**
 * This function returns a Universally Unique Identifier (UUID).
 */
FormCalc.uuid = function(n1) {
    var S4 = function() {
        return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
    };
    if(n1==1){
        return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
    }else{
    	return (S4()+S4()+S4()+S4()+S4()+S4()+S4()+S4());
    }
};
// Private functions

FormCalc.loanPmt = function(nPrincipal, nInterest, nPeriods) {
	return (nPrincipal * nInterest / ((1 - 1 / FormCalc.intRate(nInterest, nPeriods))));
};

FormCalc.intRate = function(nInterest, nPeriods) {
	return Math.pow((1 + nInterest), nPeriods)
};

FormCalc.parseFloatOrThrowError = function(obj) {
	var num = Number(obj);
	if(isNaN(num)){
		throw "<missing or illegal parameter(s).>";
	}else{
		return num;
	}
};

FormCalc.parseFloat = function(obj) {
	var num = Number(obj);
	if(isNaN(num)){
		return 0;
	}else{
		return num;
	}
};

FormCalc.checkResult = function(result) {
	if (result == Number.POSITIVE_INFINITY || result == Number.NEGATIVE_INFINITY){
	   throw "<arithmetic over/underflow.>";
	}else{
		return result;
	}
};

FormCalc.isNumeric = function(input){
	return input!=null && !isNaN(Number(input));
};

FormCalc.checkMinArgs = function(actual, expected) {
	if(actual < expected){
		throw "<missing or illegal parameter(s).>";
	}
};

FormCalc.checkMaxArgs = function(actual, expected) {
	if(actual > expected){
		throw "<missing or illegal parameter(s).>";
	}
};

FormCalc.limitAllNullArgs = function(arrayArgus) {
	var result = new Array();
	for(var i=0;i<arrayArgus.length;i++){
		if(arrayArgus[i]!=null){
			result.push(arrayArgus[i]);
		}
	}
	return result;
};

FormCalc.runWithoutNullArgs = function(func, arrayArgus) {
	var argus = FormCalc.limitAllNullArgs(arrayArgus);
	return argus.length ? func.apply(null,argus) : null;	
};

FormCalc.runWithNumericArgs = function(func, arrayArgus) {
	var argus = new Array();
	for(var i=0;i<arrayArgus.length;i++){
		if(arrayArgus[i]!=null){
        	var el = parseFloat(arrayArgus[i]);
        	if(!isNaN(el)){
        		argus.push(el);
        	}
		}
	}

	return argus.length ? func.apply(null,argus) : null;	
};

/**
 * This function returns the English text equivalent of a given number.
 * 
 */
FormCalc.WordNum=function(){
	var Ones= new Array("Zero","One","Two","Three","Four","Five",
			"Six","Seven","Eight","Nine");
	var Teens =new Array ("Ten","Eleven","Twelve","Thirteen","Fourteen",
			"Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen");
	var Tens= new Array (
			"Zero",  "Ten",   "Twenty",  "Thirty", "Forty",
			"Fifty", "Sixty", "Seventy", "Eighty", "Ninety", "Hundred" );
	var Thousands = new Array (
			"Thousand", "Million",     "Billion",
			"Trillion", "Quadrillion", "Quintillion" );
	var Cents = new Array("Cent"); 
	var Comma=new Array("");
	var Ands  =new Array ("", "And " /* used by FF99 */ );
	var Dollars=new Array ( "Dollar" );
	var Space = " ";
	var Hyphen = "-";
	var QUINTILLION = 1000000000000000000;
	var n=arguments[0];
	var f=arguments[1];
	if(n === null) {
        return null;
    }
    if(isNaN(n)||!isFinite(n)||n<0){
		return "**************"; 
	}
	
	if (f < 0 || 2 < f) {
		f = 0;
	}
	
	var dollars =   n;
	var cents =    Math.floor(((n -  Math.floor(dollars)+ 0.005) * 100));  
	if (cents >= 100) {
		dollars += 1;
		cents -= 100;
	}
	
	var s= new Array();
	var thousands = 6;
	for (var div = QUINTILLION; div >= 1 ; div/=1000) { 
		var number = Math.floor(dollars / div) ; 
		var hundreds = Math.floor(number/ 100) ;
		var tens = Math.floor((number- hundreds * 100) / 10);
		var ones = Math.floor(number- hundreds * 100 - tens * 10);  
                if(number>=1){
                    dollars -= (div * number ); 
                 }
                
                
		if (hundreds >=1) {
			s.push(Ones[hundreds]);
			s.push(Space);
			s.push(Tens[10]);
			s.push(Space);
			if (tens > 0 || ones > 0)
				s.push(Ands[0]);
		}
		if (tens >=1 ) {
			s.push((tens == 1) ? Teens[ones] : Tens[tens]);
			s.push((ones > 0 && tens != 1) ? Hyphen : Space);
		}
		if (ones >=1 && tens != 1) { 
			if (tens > 0 && ones > 0) {
				// safe since Ones contains true literal constants
				var o = Ones[ones];
				//s+=FormCalc.MylowerCase(o);  
				s.push(o.toLowerCase()); 
			}
			else {
				s.push(Ones[ones]);
			}
			s.push(Space);
		}
		thousands--;
		if (thousands >= 0 && number >= 1) {
			s.push(Thousands[thousands]);
			s.push(Comma[0]);
			s.push(Space);
		}
 
  
	}
	//
	// If less than one then use zero.
	//
	if (n < 1.) {
		s.push(Ones[0]);
		s.push(Space);
	}
	//
	// Factor in format:
	//     0 => "One Hundred Twenty-three"
	//     1 => "One Hundred Twenty-three Dollars"
	//     2 => "One Hundred Twenty-three Dollars And Forty Cents"
	//
	if (f == 1 || f == 2) {
		//
		// Append dollar CalcSymbol.
		//
		s.push(Dollars[0]);
		if ( Math.floor(n) != 1)
			s.push('s');
		//
		// Append cents.
		//
		if (f == 2) {
			s.push(Space);
			s.push(Ands[1]);
			var tens =  Math.floor(cents / 10);
			var ones =  Math.floor(cents - tens * 10);
			if (tens > 0) {
				s.push((tens == 1) ? Teens[ones] : Tens[tens]);
			}
			if (tens != 1) {
				if (tens > 0 && ones > 0) {
					// safe since Ones contains true literal constants
					var o = Ones[ones];
					s.push(Hyphen);
					s.push(o.toLowerCase());
				}
				else if (tens == 0) {
					s.push(Ones[ones]);
				}
			}
			s.push(Space);
			s.push(Cents[0]);
			if (cents != 1.)
				s.push('s');
		}
	}
	if(s[s.length-1] == ' '){
		s.pop();		
	}
	return s.join("");
};

FormCalc._Accessor = function(a) {
    if(a && typeof(a) === "object") {
        if(a.className === "field" || a.className === "exclGroup")
            return a.rawValue;
    }
    return a;
};

FormCalc._ArrayAccessor = function(a) {
    if(typeof(a) == "string") {
        var indexArray = a.lastIndexOf("]")+ 1,
            node = a.substr(0, indexArray),
            propIndex = a.indexOf(".",indexArray),
            prop = propIndex == -1 ? "" : a.substr(propIndex + 1, a.length),
            ctxNode = xfalib.runtime.xfa._contextNode(),
            list = ctxNode.resolveNodes(node),
            retArray = []
        for(var i = 0;i<list.length;i++) {
            var item = list.item(i),
                val = prop.length ? this._Accessor(item[prop]) :this._Accessor(item);
            retArray.push(val);
        }
        if(retArray.length == 1)
            return retArray[0]
        else
            return retArray;
    }
    return a;
};

FormCalc.epoch = new Date(1900,0,1)
FormCalc.epochTime = FormCalc.epoch.getTime()
FormCalc.numMillisInDay = 24*60*60*1000
FormCalc.DateFormats= ["med","short","med","long","full"]

FormCalc.num2date = function(n,fmt,locale) {
    function pad2(num) {
        return (+num)>9 ? num+"" : "0"+num;
    }
    locale = locale || "en_US"
    fmt = fmt || FormCalc.DateFmt(0,locale);
    var epoch = new Date(1900,0,1)
    epoch.setDate(n);
    var inputDate = epoch.getFullYear()+"-"+pad2((epoch.getMonth()+1))+"-"+pad2(epoch.getDate());
    return xfalib.ut.PictureFmt.formatDate(inputDate,fmt,locale);
}

FormCalc.date = function() {
    return Math.ceil((new Date().getTime() - this.epochTime)/this.numMillisInDay)
}

FormCalc.DateFmt = function(symbol,locale) {
    symbol = symbol || 0
    locale = locale || "en_US"
    return xfalib.script.Xfa.Instance._getLocaleSymbols(locale,"datePatterns."+FormCalc.DateFormats[symbol])
};
/*
 * ***********************************************************************
 * ADOBE CONFIDENTIAL
 * __________________
 *
 * Copyright 2015 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 * ***********************************************************************
 */

(function ($) {
    $.uaMatch = function( ua ) {
        ua = ua.toLowerCase();
        var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
            /(webkit)[ \/]([\w.]+)/.exec( ua ) ||
            /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
            /(msie) ([\w.]+)/.exec( ua ) ||
            ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) || [];
        return {
            browser: match[ 1 ] || "",
            version: match[ 2 ] || "0"
        };
    };
    // Not clobbering any existing $.browser
    if ( !$.browser ) {
        var
            matched = $.uaMatch( navigator.userAgent ),
            browser = {};
        if ( matched.browser ) {
            browser[ matched.browser ] = true;
            browser.version = matched.version;
        }
        // Chrome is Webkit, but Webkit is also Safari.
        if ( browser.chrome ) {
            browser.webkit = true;
        } else if ( browser.webkit ) {
            browser.safari = true;
        }
        $.browser = browser;
    }
})($);
/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/


/**
 * @package xfalib.ut.Class
 */
(function(_, xfalib){

    xfalib.ns = xfalib.ns || function (namespaceString) {
        var parts = namespaceString.split('.'),
            parent = window,
            currentPart = '';

        for(var i = 0, length = parts.length; i < length; i++) {
            currentPart = parts[i];
            parent[currentPart] = parent[currentPart] || {};
            parent = parent[currentPart];
        }

        return parent;
    };

    var Class = xfalib.ut.Class = function(options) {
        this.options = _.extend({}, this.options, options);
        if(!this.options.jsonModel)
            this.options.jsonModel = {};
        //For perf reason, we are setting jsonModel as direct property instead of using property descriptor
        this.jsonModel = this.options.jsonModel;
        this.initialize.apply(this, arguments);
    };

    _.extend(Class.prototype, {
        initialize : function(){
        },

        xfaUtil :function(){
          return xfalib.ut.XfaUtil.prototype;
        },

        copyArray : function(src,dst,options) {
            var keepReference = this.getOrElse(options, "keepReference", true);
            if(src instanceof Array)
            {
                for (var i = 0;i<src.length;i++)
                {
                    var obj;
                    if(src[i] instanceof Array)
                    {
                        obj = this._createDestination(dst, i, keepReference, []);
                        this.copyArray(src[i],obj,options);
                    }
                    else if(typeof src[i] == "object")
                    {
                        obj = this._createDestination(dst, i, keepReference, {});
                        this.copyObject(src[i],obj,options);
                    } else {
                        obj = src[i];
                    }
                    dst[i] = obj;
                }
                if(dst.length > src.length){
                    dst.splice(src.length, (dst.length - src.length));  //Remove ths rest of the extra destination items
                }
            }
        },

        /**
         *
         * @param src
         * @param dst
         * @param options e.g. {keepReference: true, exceptions:["htmlId"], transformMaps: {"dataId", function(src, options){ return src "33"+src; }}}
         */
        copyObject : function(src,dst,options) {
            var keepReference = this.getOrElse(options, "keepReference", true);
            var exceptions = this.getOrElse(options, "exceptions", []);
            var transformMaps = this.getOrElse(options, "transformMaps", {});
            if(typeof src == "object") {
                for (var child in src) {
                    if(exceptions.indexOf(child) == -1) {
                        if(src[child] instanceof Array) {
                            dst[child] = this._createDestination(dst, child, keepReference, []);
                            this.copyArray(src[child],dst[child],options);
                        }
                        else if(typeof src[child] == "object" && src[child] != null) {
                            dst[child] = this._createDestination(dst, child, keepReference, {});
                            this.copyObject(src[child],dst[child],options);
                        }
                        else{
                            if(!_.isUndefined(transformMaps[child])){
                                dst[child] = transformMaps[child](src[child], options, src);
                            }
                            else
                                dst[child] = src[child];
                        }
                    }
                }
            }
        },

        _createDestination : function(obj, property, keepReference, defaultValue) {
            if(!keepReference)
                return defaultValue;
            else if(_.isObject(obj) && !obj.hasOwnProperty(property))
                return defaultValue;
            else
                return obj[property] || defaultValue ;  //Would handle both, Array and objects
        },

        /**
         * will replace functions in the object with noop function based on a predicate function's result.
         * If no predicate is passed all functions will be disabled.
         * Warning once disabled object cant be re-enabled.
         *
         * sample predicate to disable all 'public' functions : function (funcName) { return funcName[0] != '_'}
         *
         * @param predicate
         * @private
         */
        _disableFunctions: function (predicate) {
            var noop = function () {},
                disableAll = !_.isFunction(predicate);

            _.each(_.functions(this), function (funcName) {
                if (disableAll || predicate(funcName)) {
                    this[funcName] = noop;
                }
            }, this);
        },

        /**
         * getOrElse can take multiple arguments.
         * arg1(obj): base Object
         * arg2: string representing property chain where properties are concatenated via dot
         * arg3: default value
         **/

        getOrElse : function(obj){
            var currObject = obj;
            if(arguments.length < 2)
                return currObject;
            else if(arguments.length == 2) {
                if(!_.isUndefined(currObject)){
                    return currObject;
                } else {
                    return _.clone(arguments[1]);
                }
            }
            else {
                var propChain = (arguments[1] || "").split(".");
                var defaultValue = arguments[2];
                _.each(propChain, function(prop){
                    if(_.isObject(currObject))
                        currObject = currObject[prop];
                    else
                        currObject = undefined;
                }, this);

                if(!_.isUndefined(currObject))
                    return currObject;
                else {
                    return _.clone(defaultValue) ; //May have to do deep clone in future. TODO: support for conditional clone
                }
            }
        },

        jqId: function (id) {
            return xfalib.ut.XfaUtil.prototype.jqId(id);
        },

        logger : function(){
            return this.xfaUtil().getLogger();
        },

        validateInput : function(param, dataType,fallback){
        	if(typeof param !== "undefined" && param !== null) {
        		switch(dataType) {
        		case "string":
        			param = param+"";
        			break;
        		case "object":
        			if(typeof param !== "object")
        				param = fallback;
        			break;
        	    case "integer":
                    param = parseInt(param);
                    if(isNaN(param))
                        param = fallback;
                    break;
               case "measurement":
                     break;
        		default:
        			if(dataType instanceof Array) {
                        if(!~dataType.indexOf(param))
                            param = fallback
                    }
        		}
        	}
        	return param;
        }

    });

    _.extend(Class, {
        defineProps : function(propsMap){
            _.each(propsMap, function(propDesc, propName){
                //Check property can be resolved using resolveNode
                if(propDesc.resolve) {
                    //Check whether prototype owns the object resolveProperties
                    if(!this.prototype.hasOwnProperty("resolveProperties")) {
                        //check whether prototype inherits the object resolveProperties
                        if(this.prototype.resolveProperties) {
                            //clone the object since we do not want to modify parent's prototype
                            this.prototype.resolveProperties = _.clone(this.prototype.resolveProperties);
                        }
                        else
                            this.prototype.resolveProperties = [];
                    }
                    this.prototype.resolveProperties.push(propName)
                }
                Object.defineProperty(this.prototype, propName, propDesc);

            }, this);
        },
        extend : function(props){
            var child = inherits(this, props);
            child.extend = this.extend;
            return child;
        },
        addMixins : function(mixinBakers){
            if(!_.isArray(mixinBakers)){
                mixinBakers = [mixinBakers];
            }
            _.each(mixinBakers, function(mixinBaker){
                if(mixinBaker.normalProperties){
                    _.extend(this.prototype, mixinBaker.normalProperties);
                }
                if(mixinBaker.propertyDescriptors){
                    this.defineProps(mixinBaker.propertyDescriptors);
                }
            }, this);
        }
    });

    // Shared empty constructor function to aid in prototype-chain creation.
    var ctor = function(){};

    // Helper function to correctly set up the prototype chain, for subclasses.
    // Similar to `goog.inherits`, but uses a hash of prototype properties and
    // class properties to be extended.
    function inherits(parent, protoProps, staticProps) {
        var child;
        var _super = parent.prototype;
        // The constructor function for the new subclass is either defined by you
        // (the "constructor" property in your `extend` definition), or defaulted
        // by us to simply call the parent's constructor.
        if (protoProps && protoProps.hasOwnProperty('constructor')) {
            child = protoProps.constructor;
        } else {
            child = function(){ parent.apply(this, arguments); };
        }

        // Inherit class (static) properties from parent.
        _.extend(child, parent);

        // Set the prototype chain to inherit from `parent`, without calling
        // `parent`'s constructor function.
        ctor.prototype = parent.prototype;
        child.prototype = new ctor();
        child._super = parent.prototype;
        child._superClass = parent;

        // Add prototype properties (instance properties) to the subclass,
        // if supplied.
        if (protoProps) { //_.extend(child.prototype, protoProps);
            // Copy the properties over onto the new prototype
            for (var name in protoProps) {
                if(name == "_defaults"){
                    protoProps[name] = _.extend({}, _super[name], protoProps[name]);
                }
                child.prototype[name] = protoProps[name];
            }
        }


        // Add static properties to the constructor function, if supplied.
        if (staticProps) _.extend(child, staticProps);

        // Correctly set child's `prototype.constructor`.
        child.prototype.constructor = child;

        // Set a convenience property in case the parent's prototype is needed later.
        child.__super__ = parent.prototype;

        return child;
    };
})(_, window.xfalib);
/**
 * Created by vdua on 2/18/2015.
 */
(function (_, xfalib) {
    var XMLUtils = {
        dataSom2xpath: function (dataSom) {
            var xpath = "";

            if (!_.isEmpty(dataSom)) {
                // any dot preceded by ], takes care of dot-s in name,
                // and remove constant prefix "xfa[0].datasets[0].data[0]" and form root name, then join using '/'
                _.each(dataSom.split(/\]\./).slice(4),
                    function (part) {
                        var openBracketPos = part.lastIndexOf('[');
                        xpath += part.substring(0, openBracketPos + 1) +
                            (parseInt(part.substring(openBracketPos + 1)) + 1) + // increment index by 1 for xpath query
                            "]/";
                    });

                if (_.isEmpty(xpath)) {
                    xpath = dataSom;
                } else if (xpath[xpath.length - 1] === '/') {
                    xpath = xpath.slice(0, -1);
                }
            }

            return xpath;
        },

        /**
         * Converts an xPathResult of type iterator to an array
         * @param xPathResult
         * @returns {Array}
         */
        iteratorToArray: function (xPathResult) {
            var result = [];
            // in some browsers, if xpath is invalid xPath result is null whereas some browsers return XpathResult with empty iterator
            var node = xPathResult ? xPathResult.iterateNext() : null;
            while (node != null) {
                result.push(node);
                node = xPathResult.iterateNext();
            }
            return result;
        },
        /**
         * Wrapper API for document.evaluate to provide cross-browser support.
         * @param xpath
         * @param node
         * @param nsResolver
         * @param resultType
         * @param result
         * @returns {Object|*}
         */
        evaluateXPath: function (xpath, node, nsResolver, resultType, result) {
            try {
                if(_.isEmpty(xpath) || !_.isString(xpath) || !(node instanceof Node)) {
                    return null;
                }

                // Determine the appropriate document context for searching.
                var searchContext = node instanceof Document ? node : node.ownerDocument;
                // Check if the document.evaluate function is undefined or if we're in a server-side context.
                var isEvaluateUndefined = typeof searchContext.evaluate === 'undefined';
                var isServerSide = window.guideBridge && window.guideBridge.hostName === "server";
                var needsXPathPolyfill = isEvaluateUndefined || isServerSide;
                if (needsXPathPolyfill) {
                    // Install the wgxpath polyfill to provide evaluate functionality.
                    wgxpath.install(window, true);
                    // Assign the newly installed evaluate function to the search context.
                    searchContext.evaluate = window.document.evaluate;
                }

                var documentToEval = searchContext.evaluate ? searchContext : document;
                xpath = this.sanitizeXPath(xpath);

                return documentToEval.evaluate(xpath, node, nsResolver, resultType, result);

            } catch (exception) {
                xfalib.ut.XfaUtil.prototype.getLogger().error("Could not evaluate xpath: " + xpath  + exception);

            }

        },
         /**
         *Removes all [*] other than ['numeric'] from xpath
         *@param xpath
         *@returns xpath after removing "[*]"
         */
         sanitizeXPath: function(xpath) {
             var xpathArray=xpath.split("/"),
                 resultXpath = _.map(xpathArray, function (path) {
                 return path.replace(/\[(.*\D+.*)\]|\[\]/g,"");
             }).join("/");
             return resultXpath;
         },

        /**
         * Creates all the Elements (if they don't exist) in the xpath leading to the node being searched for in the
         * xpath relative to the element. Optionally creates the node as well if bParentsOnly is false
         * @param xpath
         * @param element
         * @param bParentsOnly whether to create only the parents or the node as well
         * @returns node that is being represented by the xpath relative to the element.
         */
        createElementsFromXPath: function (xpath, element, bParentsOnly) {
            if (xpath != null || element != null) {
                var parts = xpath.split("/"),
                    actualParts = bParentsOnly ? _.initial(parts) : parts,
                    el = element;
                _.each(actualParts, function (part, index) {
                    var som = part.match(/^([^[]+)(\[(\d+)\])?/),
                        childEl;
                    if (som == null) {
                        xfalib.ut.XfaUtil.prototype.getLogger().error("Unsupported expression in Bindref " + part);
                        return null;
                    }
                    //only the last element can be attribute
                    childEl = this.findOrCreateElement(part, el, index === actualParts.length - 1);
                    el = childEl;
                }, this);
                return el;
            }
            return null;
        },

        /**
         * Form an xpath part returns the index as well as the tagName. Index can be * as well
         * @param xpathName
         * @returns {*}
         * @private
         */
        _getElementNameAndIndexFromXPathPart: function (xpathName) {
            var som  =  xpathName.match(/^([^[]+)(?:\[(\d+|\*)\])?/);
            if (som !== null) {
                return {
                    name: som[1],
                    index: som[2] || 0
                };
            }
            return null;
        },

        /**
         * create an element with the tagName elementName for the ownerDocument of element.
         * @param elementName
         * @param element
         * @returns {HTMLElement}
         */
        createElement: function (elementName, element) {
            var el = element.ownerDocument.createElement(elementName);
            return el;
        },

        /**
         * Searches for the nodeXpath relative to element. If it doesn't exists creates it and returns the node
         * @param element
         * @param nodeXpath
         * @param bAttribute if true then check for attribute otherwise not.
         * @returns {Node|*}
         */
        findOrCreateElement: function (nodeXpath, element, bAttribute) {
            try {
                if (element == null) {
                    return null;
                }
                var result = this.evaluateXPath(nodeXpath, element, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null),
                    el = result.iterateNext(),
                    res;
                if (el == null) {
                    res = this._getElementNameAndIndexFromXPathPart(nodeXpath);
                    if (res != null) {
                        if (bAttribute && res.name.match(/^@/)) {
                            var attrName = res.name.replace(/^@/, "");
                            el = element.ownerDocument.createAttribute(attrName);
                            element.setAttributeNode(el);
                        } else {
                            el = element.ownerDocument.createElement(res.name);
                            element.appendChild(el);
                        }
                    }
                }
                return el;

            } catch (exception) {
                xfalib.ut.XfaUtil.prototype.getLogger().error("Following exception "
                    +  "occurred while executing findOrCreateElement " + exception);
            }

        },

        /**
         * Returns the Root Form Elment from the xmlDocumentElement
         * @param xmlDocumentElement It can be a document or Element. If the root element is xdp element, it returns
         *        the grand grand child of that element. otherwise the root element is returned. The root
         *        Element can be either the element itself or documentElement of the element.
         */
        getXFARootFormElementFromXML: function (xmlDocumentElement) {
            if(_.isUndefined(document.evaluate)) {
                wgxpath.install();
            }
            var isElement = xmlDocumentElement instanceof Element,
                docElemName = isElement ? xmlDocumentElement.nodeName : xmlDocumentElement.documentElement.nodeName,
                rootElement = isElement ? xmlDocumentElement : xmlDocumentElement.documentElement,
                nodeList;

            if ("xdp:xdp" === docElemName || "xdp" === docElemName) {
                if (xfalib.ut.XfaUtil.prototype.isIE()) {
                    //IE doesn't support evaluating namespace elements
                    var datasets = rootElement.firstElementChild,
                        data = datasets.firstElementChild;
                    rootElement = data.firstElementChild;
                } else {
                    // assumption is that the xml will be of format <xdp><datasets><data><form1>
                    // TODO: change first * to xfa:datasets
                    nodeList = this.evaluateXPath("*/xfa:data/*", rootElement, formBridge.nsResolver,
                                            XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                    rootElement = nodeList.iterateNext();
                }
            }
            return rootElement;
        },

        /**
         * Returns an object containing the prefix and namespaces present in the rootElement. For default namespace the
         * prefix is "_default"
         * @param rootElement {Element} xml element which has to be looked for namespaces
         * @returns {object} object whose keys are the prefix and values are the namespace
         */
        getNamespaces: function (rootElement) {
            var namespaces = {
                "_default" : null
            };
            _.each(rootElement.attributes, function (attr) {
                var name = attr.name,
                    parsedAttrName = name.match(/^xmlns(?:\:(.*))?/),
                    isNamespace = parsedAttrName != null,
                    namespaceName = isNamespace ? parsedAttrName[1] || "_default" : null;
                if (namespaceName) {
                    namespaces[namespaceName] = attr.value;
                }
            });
            return namespaces;
        },

        /**
         * Returns a namespace resolver given a element. The nsResolver returns the namespace given a prefix by
         * using the namespaces mentioned in the element.
         * @param rootElement element from which to create the nsResolver
         * @returns {function} the function returns the namespace given a prefix.
         */
        getNsResolver: function (rootElement) {
            var namespaces = this.getNamespaces(rootElement),
                nsResolver = (function (namespaces) {
                    return function (nsPrefix) {
                        var namespace = formBridge.nsResolver(nsPrefix) || namespaces[nsPrefix];
                        return namespace;
                    };
                }(namespaces));
            return nsResolver;
        },

        /**
         * Removes default namespaces from xml, basically the namespace defined as xmlns="some namespace". The
         * side-effect of the API is it removes the string "xmlns='some namespace'" from any attribute value as well.
         * @param xml {string}
         * @returns {string}
         */
        removeDefaultNamespace: function (xml) {
            var stringRegex = "(\\s+)" + // any number of spaces
                             "(xmlns=" + // then xmlns=
                            "('[^']*'|\"[^\"]*\"))" + // then value in single quotes ('[^']') or
                                                    //                 double quotes ("[^"]")
                            "(?=[^<>]*>)",  // followed by closing tag (implies attribute) and before another
                                           // opening tag(implies text)
                regex = new RegExp(stringRegex, "g");
            return xml.replace(regex, "$1");
        }
    };
    xfalib.ut.XMLUtils = XMLUtils;
}(_, xfalib));
/**
 * @package xfalib.ut.Logger
 * @import xfalib.ut.Class
 */

(function(_, xfalib, $){
    var categoryAcronyms = {
                            "a": "xfa",
                            "b": "xfaView",
                            "c": "xfaPerf"
        },
        loggerTypes = ["off", "console", "server", "consoleServer"];
    var Logger = xfalib.ut.Logger = xfalib.ut.Class.extend({

//      Count of log messages so far.
        LOG_COUNT : {
            level : {
                "FATAL" : 0,
                "ERROR" : 0,
                "WARN" : 0,
                "INFO" : 0,
                "DEBUG" : 0,
                "TRACE" : 0,
                "ALL" : 0
            },
            category : {
                "xfa" : 0,
                "xfaView" : 0,
                "xfaPerf" : 0,
                "Unknown" : 0
           }
        },

        /**
         * Log level to turn logging off (default).
         * @static
         * @final
         * @type Number
         */
        OFF : 0,

        /**
         * Log level for fatal error messages.
         * @static
         * @final
         * @type Number
         */
        FATAL : 1,

        /**
         * Log level for error messages.
         * @static
         * @type Number
         * @final
         */
        ERROR : 2,

        /**
         * Log level for warning messages.
         * @static
         * @type Number
         * @final
         */
        WARN : 3,

        /**
         * Log level for info messages.
         * @static
         * @type Number
         * @final
         */
        INFO : 4,

        /**
         * Log level for debug messages.
         * @static
         * @type Number
         * @final
         */
        DEBUG : 5,

        /**
         * Log level for trace messages.
         * @static
         * @type Number
         * @final
         */
        TRACE : 6,

        /**
         * Log level for all messages.
         * @static
         * @type Number
         * @final
         */
        ALL : 7,


        logLevelNames : ["OFF", "FATAL", "ERROR", "WARN", "INFO", "DEBUG", "TRACE", "ALL"],

        initialize : function(){
            var str = "",
                that =this;
            Logger._super.initialize.call(this);
            this.logs = {};
            this.logMessages = "";
            this.logServiceProxy = this.options.logServiceProxy;
            this.contextPath = this.options.contextPath;
            this.renderContext =  this.options.renderContext;
            if(this.jsonModel.logConfigString) {
                _.extend(this.jsonModel, this.parse(this.jsonModel.logConfigString));
            }
            _.each(this.jsonModel.category, function(category) {
                that.LOG_COUNT.category[category] = 0;
            })
        },

        /**
         * parses a log config string of the form <0,1,2,3>-<category string><level integer>-<category string><level integer>..
         * and returns an a config object that logger uses. The function is a private and not to be called outside
         * this function
         *
         * category can not contain numbers and only valid characters are a-zA-Z
         * level can be any integer.
         *
         * category string is converted into actual category for the logger by using default categoryAcronyms
         * [a : xfa, b: xfaView, c: xfaPerf} and the categoryAcronyms passed to the options while instantiating the
         * object. If not found in both the acronyms then the value category string is used as actual category
         *
         * For example for the input string 1-a9-b9-c9 return object is
         * {on: true, category: [xfa,xfaView, xfaPerf], level: [9, 9, 9], type: console}
         *
         * For the input string 1-a9-b9-c9-d9-e11 with options.categoryAcronyms {a:a, d:AF} return object is
         * {on: true, category: [xfa,xfaView, xfaPerf, AF, e], level: [9, 9, 9, 9, 11], type: console}
         */
        parse : function(configString) {
            var arr = configString.split("-"),
                logType = _.first(arr),
                logConfig = _.rest(arr),
                res = {
                    on: logType === "0" ? "false": "true",
                    category: [],
                    level:[],
                    type:loggerTypes[parseInt(logType)]
                };
           _.each(logConfig, function(item, index) {
                var config = item.match(/^([A-Za-z]+)(\d+)$/),
                    category;
                if (config && config.length === 3) {
                    category = this.getOrElse(categoryAcronyms, config[1],
                                    this.getOrElse(this.jsonModel, "categoryAcronyms." + config[1], config[1]));
                    res.category.push(category);
                    res.level.push(parseInt(config[2]));
                } else {
                    //calling this because logger is not initialized as of now
                    this.consoleHandler(this.resolveMessage(xfalib.locale.LogMessages["ALC-FRM-901-020"],
                                                    [item, configString]))
                }
            }, this);
            return res;
        },

        /*
         *
         */
        resolveMessage : function(message, snippets) {
            snippets = snippets || [];
            return message.replace(/{(\d+)}/g, function(match, number) {
                return typeof snippets[number] != 'undefined'
                    ? snippets[number]
                    : match
                    ;
            });
        },

        /**
         * Writes a message to the console.
         * @private
         * @param {Number} level The log level
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         * @return The log message
         * @type String
         */
        log : function(category, level, message, snippets) {
            var d= new Date();
            var day = d.getDate();
            var month = d.getMonth() + 1;
            var year = d.getFullYear();
            var mili = d.getMilliseconds();
            var sec = d.getSeconds();
            var min = d.getMinutes();
            var hour = d.getHours();
            var date = day + "." + month + "." + year +" " + hour + ":" + min + ":" + sec + ":" + mili;
            if(this.jsonModel && this.jsonModel.category) {
                for(var i = 0; i<this.jsonModel.category.length; i++) {
                    if (level != 0 && this.jsonModel.level[i] >= level && this.jsonModel.category[i] == category && this.jsonModel.on == "true") {

                        var resolvedMessage = message;
                        if(snippets){
                            //resolve message with snippet
                            resolvedMessage = this.resolveMessage(message, snippets);
                        }

                        var text = "";
                        text += date ;
                        text += " *" + this.logLevelNames[level] + "*";
                        text += " [" +  category + "]" ;
                        text += "  " + resolvedMessage + "\r\n" ;
                        this.logMessages += text ;
                        if(this.jsonModel.type == "console" || this.jsonModel.type == "consoleServer" ) {
                            ++this.LOG_COUNT.category[category || 'Unknown'];
                            ++this.LOG_COUNT.level[this.logLevelNames[parseInt(level) < 8? level:7]];
                            this.consoleHandler(text, level);
                        }
                    }
                }
            }
        },

        consoleHandler : function(text, level){
            if(typeof console != "undefined") {
                var levelName = typeof this.logLevelNames[level] === "string"
                    ? this.logLevelNames[level].toLowerCase()
                    : "log",
                    logFunction = console.log;
                if (typeof console[levelName] === "function") {
                    logFunction = console[levelName]
                }
                logFunction.call(console, "\n\n\n" + text);
                //Error log already shows the call stack for debugging.
                if(levelName !== "error") {
                    try {
                        n.test
                    } catch (exception) {
                        if (exception.stack) {
                            logFunction.call(console, exception.stack.replace("ReferenceError: n is not defined", ""));
                        }
                    }
                }
            }

        },

        /*
         *  Helper function to ger submit service proxy url
         */
        _getLogServiceProxyUrl: function() {
            var logServiceProxyUrl = "";
            if(this.logServiceProxy)
                logServiceProxyUrl += this.logServiceProxy;
            else //finally hard code it
                logServiceProxyUrl += ((this.contextPath && this.contextPath != "/") ? this.contextPath : "") + "/content/xfaforms/profiles/default.log.html";
            return logServiceProxyUrl;
        },

        _invokeAtServer: function(options) {
            var localSubmitUrl =  this._getLogServiceProxyUrl();
            var params = {
                    async: true,
                    url: localSubmitUrl,
                    type: 'POST',
                    contentType: 'application/x-www-form-urlencoded; charset=UTF-8',
                    data: options
                };
            $.ajax(params);
        },

        isServerLoggingEnabled : function(){
            if((this.jsonModel.on == "true") && (this.jsonModel.type == "server" || this.jsonModel.type == "consoleServer"))
                return true;
            else
                return false;
        },

        serverHandler :function() {
            var options = {'logMessages' : this.logMessages, 'renderContext' : this.renderContext};
            this._invokeAtServer(options);
            this.logMessages = "" ;
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #FATAL} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        fatal : function(category, message, snippets) {
            this.log(category, this.FATAL, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #ERROR} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        error : function(category, message, snippets) {
            this.log(category, this.ERROR, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #WARN} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        warn : function(category, message, snippets) {
            this.log(category, this.WARN, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #INFO} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        info : function(category, message, snippets) {
            this.log(category, this.INFO, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #DEBUG} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        debug : function(category, message, snippets) {
            this.log(category, this.DEBUG, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #TRACE} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        trace :  function(category, message, snippets) {
            this.log(category, this.TRACE, message, snippets);
        },

        isLogEnabled : function(category, level) {
            if(this.jsonModel.on == "true") {
                var pos = this.jsonModel.category.indexOf(category) ;
                if(this.jsonModel.level[pos] >= level)
                    return true;
            }
            return false;
        }

    });
})(_, xfalib, $);
/**
 * @package xfalib.ut.EventClass
 * @import xfalib.ut.Class
 */
(function(_, xfalib){
    // Regular expression used to split event strings
    // Regular expression used to split event strings
    var eventSplitter = /\s+/;

    // A module that can be mixed in to *any object* in order to provide it with
    // custom events. You may bind with `on` or remove with `off` callback functions
    // to an event; trigger`-ing an event fires all callbacks in succession.
    //
    var EventClass = xfalib.ut.EventClass =  xfalib.ut.Class.extend({

        // Bind one or more space separated events, `events`, to a `listener`
        // object. The object should implement `handleEvent` function which will be
        // called on event dispatch
        on: function(event, listener, context) {

            var calls, list,retVal = true;
            var fnCallback = _.isFunction(listener) ? listener : null;
            if (!listener || (!listener["handleEvent"] && !fnCallback)) return false;

            calls = this._callbacks || (this._callbacks = {});

            list = calls[event] || (calls[event] = []);
            if(fnCallback){
                context = context || this;
                var found = _.find(list, function(callback){
                    return (callback.fn == fnCallback && callback.context == context);
                }, this);
                if(found)
                    return false;
                else {
                    list.push({"fn" : fnCallback, "context": context});
                }
            }
            else{
                if(~list.indexOf(listener))
                    return false;
                else
                    list.push(listener);
            }

            return  true;
        },

        // Remove one or many callbacks. If `listener` is null, removes all listener for the
        // event. If `events` is null, removes all bound callbacks for all events.
        off: function(events, listener, context) {
            var event, calls, node;

            // No events, or removing *all* events.
            if (!(calls = this._callbacks)) return;
            if (!(events || listener)) {
                delete this._callbacks;
                return this;
            }

            var fnCallback = _.isFunction(listener) ? listener : null;
            // Loop through the listed events and contexts and remove the required ones.
            events = events ? events.split(eventSplitter) : _.keys(calls);
            while (event = events.shift()) {
                node = calls[event];
                calls[event] = _.filter(calls[event],function(elem) {
                    if(typeof(listener) !== "undefined"){
                        if(fnCallback && elem.fn == fnCallback && elem.context == context)
                            return false;
                        else if(!fnCallback && listener === elem)
                            return false;
                    }
                    else{
                        return false;
                    }
                    return true;
                });
                if(!calls[event].length)
                    delete calls[event];
            }

            return this;
        },

        // Trigger one or many events, firing all bound callbacks. Callbacks are
        // passed the same arguments as `trigger` except the first
        trigger: function(events) {
            var event, calls, rest;
            if (!(calls = this._callbacks)) return this;
            events = events.split(eventSplitter);
            var payLoad = _.rest(arguments);
            while (event = events.shift()) {
                _.each(calls[event],function(callback) {
                    if(callback.fn && callback.context){
                        callback.fn.apply(callback.context, payLoad);
                    }
                    else if (_.isFunction(callback.handleEvent)){
                        callback.handleEvent.apply(callback, payLoad);
                    }
                });
            }

            return this;
        }

    });


})(_, xfalib);


(function (_, $, xfalib) {
    var XfaUtil = xfalib.ut.XfaUtil = function () {
        },
        registeredLocaleProperties = null,
        timeoutListenerAttached = false,
        timeouts = [],
        attachClearTimeoutListener = function (timeout) {
            timeouts.push(timeout);
            if (timeoutListenerAttached === false) {
                $(window).one("destroy.xfa", function () {
                    _.each(timeouts, function (_timeout) {
                        clearTimeout(_timeout);
                    });
                    timeouts = [];
                    timeoutListenerAttached = false;
                });
                timeoutListenerAttached = true;
            }
        };
    _.extend(XfaUtil.prototype, {
        _globalUniqueId: (new Date()).getTime(),
        logger: null,

        formScaleFactor: 1,      // used to appropriately scale the form when contained inside an iframe

        getOrElse: xfalib.ut.Class.prototype.getOrElse,
        //map of event names between XTG and Mobile Form
        //Mobile Form uses different names for some the event and let's fix those names before sending them to XTG.
        _xtgEventName: {
            "$formready": "ready",
            "$layoutready": "ready"
        },

        generateUID: function () {
            return "UID" + (++XfaUtil.prototype._globalUniqueId);
        },

        matchJsonType: function (jsonModel, _class) {   //TODO: handle getOrElse
            return (jsonModel && _class && XfaUtil.prototype.getOrElse(jsonModel._class, "").toLowerCase() == ("" + _class).toLowerCase());
        },

        $data: function (elem, name, data) {
            if (!$.data(elem, "_xfaInitialized")) {
                //Initialized data- attributes parse for once using this call.
                // Next onward don't use this. Instead use $.data which is cheap/
                $(elem).data();
                $.data(elem, "_xfaInitialized", true); //Mark the element to say that data has been initialized.
            }
            return $.data(elem, name, data);
        },

        /*
         * alternative to jQuery.css which sets style properties directly through element.style. This is much faster then
         * corresponding jQuery.css alternative.
         *
         * Warning: this only supports standard css property names and does not do any pre-processing of name and value.
         * So calling this, make sure the style names are compatible.
         */
        $css: function (elem, stylesObj) {
            // Exclude the following css properties to add px. copied from jquery.cssNumber to add hyphenated style names
            var cssNumber = {
                "fillOpacity": true,
                "fill-opacity": true,
                "fontWeight": true,
                "font-weight": true,
                "lineHeight": true,
                "line-height": true,
                "zIndex": true,
                "z-index": true,
                "opacity": true,
                "orphans": true,
                "widows": true,
                "zoom": true
            };

            for (var prop in stylesObj) {
                var value = stylesObj[prop];
                // If a number was passed in, add 'px' to the (except for certain CSS properties)
                if (_.isNumber(value) && !cssNumber[ prop ]) {
                    value += "px";
                }
                elem.style[prop] = value;
            }
        },

        isTableHF: function (iChildNode) {
            //model can be a Node object or simply a json
            var assistJson = _.find(iChildNode.children, function (jChild) {
                return jChild._class == "assist";
            }, this);
            var childRole = (assistJson || {}).role;
            if (childRole == "TH" || childRole == "TF")
                return true;
            else
                return false;
        },

        getUiOneOfChildTag: function (uiParent) {
            var uiEl = _.find(uiParent.children, function (child) {
                return child._class == "ui";
            });
            if (!uiEl)
                return undefined;
            var uiOneOfChildMap = xfalib.runtime.xfa._templateSchema._getOneOfChild("ui");
            var uiOneOfChild = _.find(uiEl.children, function (child) {
                return uiOneOfChildMap[child._class] == true;
            });
            if (!uiOneOfChild)
                return undefined;
            return uiOneOfChild._class;
        },

        //TODO: this should be removed. One of the worst function.
        dIndexOf: function (searchArray, item2Find) {
            var ind = -1;
            _.find(searchArray, function (item, index) {
                return item == item2Find && (ind = index)
            });
            return ind;
        },

        splitStringByWidth: function (value, width, refEl) {
            var i = value.length , expectedWidth;
            do {
                expectedWidth = xfalib.view.util.TextMetrics.measureExtent(value.slice(0, i), {"refEl": refEl, maxWidth: -1}).width;
                i--;
            } while (expectedWidth > width)
            if (i != value.length - 1)
                return value.slice(0, i + 1);
            return value;
        },

        isRepeatabeEl: function (elTag) {
            if (elTag == "subform" || elTag == "subformSet")
                return true;
            else
                return false;
        },

        /**
         * @function
         * stripOrCall(toStrip, diffFunc, fArgs)
         * @description
         * common utility function to handle final submission payload stripping
         * @param {bool} toStrip : flag to signify whether to optimize jsonModelDiff size, by stripping off unnecessary properties
         * @param {function} diffFunc : callback func. call in case submit is not on
         * @param {Array} fArgs : arguments to be passed to the diff func.
         * @returns {object} object containing the jsonDiff
         */
        // should ALWAYS be called with a flag signifying if a submission is in progress,
        // and a callback function to compute the json to be sent back during submission, usually an apt '_computeJsonDiff'
        stripOrCall: function (toStrip, diffFunc, fArgs) {
            if (toStrip) {
                return {
                    "changed": false,
                    "jsonDifference": {}
                };
            }
            else if (_.isFunction(diffFunc)) {
                return diffFunc.apply(this, fArgs);
            }
        },

        /**
         * @function
         * partialStripOrCall(stripLvl, diffFunc, fArgs)
         * @description
         * common utility function to handle final submission payload stripping or for output of getFormState.
         * @param {int} diff_level : flag to signify whether to optimize jsonModelDiff size, by stripping off unnecessary properties
         *                        must be 0,1, or 2, as with "diff_level" param of _computeJsonDiff.
         * @param {function} diffFunc : callback func. call in case submit is not on
         * @returns {object} object containing the jsonDiff
         */
        partialStripOrCall: function (diff_level, diffFunc) {
            var diffObj = diffFunc.call(this, diff_level);

            if (!diffObj.changed) {
                if(diff_level === 1) {
                    diffObj = {
                        "changed": true,
                        "jsonDifference": {
                            "_class": this.jsonModel._class,
                            "name": this.jsonModel.name
                        }
                    };
                } else {
                    diffObj.jsonDifference = {};  // don't need stuff for other cases
                }
            }

            return diffObj;
        },

        /**
         * @function
         * stripObject(obj, exceptionNames)
         * @description
         * Utility function to strip unnecessary properties from an object
         * @param {object} obj : the object to strip
         * @param {Array} exceptionNames : array holding names of important properties to preserve
         * @returns {boolean} : true if this obj, or any of it's descendant is returned un-stripped
         */
        stripObject: function (obj, exceptionNames) {
            if (_.isEmpty(obj) || !_.isObject(obj)) {
                return true;
            } else {
                var dontStrip = false;
                _.each(_.keys(obj), function (propName) {
                    var keepProp = false;
                    if (!_.contains(exceptionNames, propName)) {
                        if (_.isArray(obj[propName])) {
                            _.each(obj[propName], function (arrElem) {
                                var isUnStripped = XfaUtil.prototype.stripObject(arrElem, exceptionNames);
                                keepProp = keepProp || isUnStripped;
                            });
                        } else if (_.isObject(obj[propName])) {
                            keepProp = XfaUtil.prototype.stripObject(obj[propName], exceptionNames);
                        }

                        if (!keepProp) {
                            delete obj[propName];
                        } else {
                            dontStrip = true;
                        }
                    } else {
                        dontStrip = true;
                    }
                });
                return dontStrip;
            }
        },

        computeDomJsonDiff: function (domNode, diff_level) {
            var changed = true;
            if (domNode.hasOwnProperty("_modelChanged")) {
                changed = domNode._modelChanged;
            }
            var jsonDiff = {};
            if (changed) {
                this.copyObject(domNode.jsonModel, jsonDiff, {"exceptions": ["children", "{default}", "extras"]});
            } else {
                jsonDiff = {_class: domNode.className};
            }
            if (!changed && domNode.jsonModel.hasOwnProperty("name")) {
                jsonDiff.name = domNode.jsonModel.name;
            }
            if (domNode.name === "FS_EXTRAS" && diff_level === 3) {
                domNode._childModified = true;
            }
            return {
                "changed": changed,
                jsonDifference: jsonDiff
            };
        },

        getLogger: function () {
            return XfaUtil.prototype.logger || XfaUtil.prototype.getOrElse(xfalib, "runtime.xfa.Logger", null);
        },

        getErrorManager: function () {
            return XfaUtil.prototype.getOrElse(xfalib, "runtime.xfa.ErrorManager", null);
        },

        XFA_CLICK_EVENT: "xfaclick",
        XFA_EXIT_EVENT: "xfaexit",
        XFA_ENTER_EVENT: "xfaenter",
        XFA_CHANGE_EVENT: "xfachange",
        XFA_PREOPEN_EVENT: "xfapreopen",

        btwn: function (val, a, b) {
            return val > a && val < b;
        },

        // function to detect if Browser is chrome / safari (webkit)
        isWebkit: function () {
            return  !!$.browser.webkit || /webkit/.test(navigator.userAgent.toLowerCase()) || !!window.chrome || !!$.browser.chrome || /chrom(e|ium)/.test(navigator.userAgent.toLowerCase()) || !!$.browser.safari || !!window.webkitURL ||
                ( /safari/.test(navigator.userAgent.toLowerCase()) &&
                    /apple computer/.test(navigator.vendor.toLowerCase()) );

            // TODO : find a better way to do this as $.browser is deprecated and
            // userAgent may be spoofed
        },

        clearTimeoutOnDestroy: function (timeout) {
            attachClearTimeoutListener(timeout);
        },

        // function to detect if Browser is  safari
        isSafari: function () {
            return ( /safari/.test(navigator.userAgent.toLowerCase()) &&
                    /apple computer/.test(navigator.vendor.toLowerCase()) );
        },

        getLocaleStrings: function () {
            return xfalib.locale.Strings;
        },

        getLogMessages: function () {
            return xfalib.locale.LogMessages;
        },

        /*
         * This function should not be added in the prototype of any Object
         * as in the case of other functions
         */
        registerLocaleProperties: function (props) {
            registeredLocaleProperties = props;
        },

        /*
         * This function should not be added in the prototype of any Object
         * as in the case of other functions
         */
        getDefaultLocaleProperty: function (property) {
            var localeProps = registeredLocaleProperties || this.getOrElse(xfalib, "script.Xfa._defaultLocale", null);
            return this.getOrElse(localeProps, property, null);
        },

        /**
         * Encodes <script> and </script> with &lt;script&gt; and &lt;/script&gt;
         * Does same with img, video and audio tags also.
         * These tags are being removed since scripts can be run through
         * <img onerror="script" /> (same for audio and video).
         */
        encodeScriptableTags: function (str) {
            var index;
            if (_.isString(str)) {
                return str.replace(/<(\/?)(script[^<>]*)>/gi, '&lt;$1$2&gt;')
                    .replace(/<(\/?)(img[^<>]*)>/gi, '&lt;$1$2&gt;')
                    .replace(/<(\/?)(video[^<>]*)>/gi, '&lt;$1$2&gt;')
                    .replace(/<(\/?)(audio[^<>]*)>/gi, '&lt;$1$2&gt;')
            }
        },

        /**
         *
         * @param id : a string representing an HTML element id.
         *
         * return after applying an escaping '\' before each # . : [ ]
         */
        jqId: function(id) {
            return "#" + id.replace(/(#|:|\.|\[|\])/g, "\\$1");
        },

        _triggerOnBridge: function (eventName, target, property, oldVal, newVal) {
            var evnt = xfalib.script.XfaModelEvent.createEvent(eventName, target,
                property, oldVal, newVal);
            if(formBridge){
                window.formBridge.trigger(eventName, evnt);
            }
        },

        /*
         * pads the passed in String str by pre-pending padChars to convert it to a string of given width.
         * If string length is already greater that equal to given width, original string is returned.
         */
        padString : function (str, width, padChar) {
            padChar = padChar || '0';
            str = str + '';
            return str.length >= width ? str : new Array(width - str.length + 1).join(padChar) + str;
        },

        /**
         * returns true if the browser is IE otherwise false
         * @returns {boolean}
         */
        isIE: function () {
            return $.browser.msie || (navigator.appName === "Netscape" && navigator.userAgent.match(/Trident\//))
        },

        /**
         * returns false if other browser
         * if ie tries to return browser version (non falsy)
         * @returns {*}
         */

        detectIE: function () {
            // 1st try jq
            if($.browser.msie) {
                if($.browser.version && parseInt($.browser.version, 10)) {
                    return parseInt($.browser.version, 10);
                }
            }

            var ua = window.navigator.userAgent;

            // IE 10
            // ua = 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)';

            // IE 11
            // ua = 'Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko';

            // IE 12 / Spartan
            // ua = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0';

            // Edge (IE 12+)
            // ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586';

            var msie = ua.indexOf('MSIE ');
            if (msie > 0) {
                // IE 10 or older => return version number
                return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
            }

            var trident = ua.indexOf('Trident/');
            if (trident > 0) {
                // IE 11 => return version number
                var rv = ua.indexOf('rv:');
                return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
            }

            var edge = ua.indexOf('Edge/');
            if (edge > 0) {
                // Edge (IE 12+) => return version number
                return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
            }

            // other browser
            return false;
        },
        /**
         * returns true if the browser is chrome otherwise false
         * @returns {boolean}
         */
        detectChrome : function () {
            return (!!window.chrome || !!$.browser.chrome || /chrom(e|ium)/.test(navigator.userAgent.toLowerCase()));
        },

        /**
        * @param {String} val: value to be verified
        * @returns {boolean}
        * returns true if the provided string contains DOM element
        */
        isHTML: function(val) {
            //check whether string contains tags, so that $val does not contain result of the val used as selector
            // eg: val = "a" will return result for $(val) which is not required
            if(val && /<[a-z][\s\S]*>/.test(val)) {
                try {
                    var $val = $(val);
                    return $val.length > 0;
                } catch (exception) {
                    // if jquery throws exception that means string is not a proper HTML
                    return false;
                }
            } else {
                return false;
            }
        },

        /**
         * returns true if passed key is non printable, false otherwise.
         * @param {String} key event.key property of a Keyboard event
         */
        isNonPrintableKey : function (key) {
            return (key   // In IE, event.key returns words instead of actual characters for some keys.
               && !_.contains(['MozPrintableKey','Divide','Multiply','Subtract','Add','Enter','Decimal','Spacebar','Del'],key)
               && key.length != 1 )
        },

        /**
        * returns true for ipad
        * @returns {boolean}
        */
        _isIpad : function () {
            return navigator.userAgent.match(/iPad/i) != null;
        },

        /**
        * returns true if the subform is table or having role table else false
        * @param {Object} view
        */
        _tableCheckForAccessibility : function (view) {
            var assist = view.model.getElement("assist", 0, true);
            return this.getOrElse(view, "layoutModel.layout", null) == xfalib.view.LayoutConst.LAYOUT_TABLE
                || this.getOrElse(assist, "role", null) == "Table";
        },

        /**
        * returns value of tooltip to be assigned as title based on values provided in accessibility
        * @param {Object} model
        * @returns toolTipText
        */
        _getToolTipText : function (model) {
            var assist = model.getElement("assist", 0, true),
                toolTipText = "";
            // going against xfa spec, on hover show tooltip or speak text or element name, don't show caption as it's already visible
            // assist priority doesn't matter, but selecting none will disable tooltip on hover
            if (this.getOrElse(assist, "speak.disable", 0) != 1) { // loose compare string value
                toolTipText = this.getOrElse(assist, "toolTip.value", "") ||
                    this.getOrElse(assist, "speak.value", "")   ||
                    this.getOrElse(model, "jsonModel.name", "");
            }
            return toolTipText;
        },

        /**
        * returns value of mandatory message
        * @param {Object} model
        * @returns mandatoryMessage
        */
        _getMandatoryMessage : function (model) {
            var defaultMessage = model._defaults.validate.message.defaultMessage,
                msg = this.getOrElse(model, "validate.message.nullTest", defaultMessage);
            return (msg && msg.value) ? msg.value : defaultMessage.value;
        },
        /**
        * returns boolean based on val1, val2, checkEqual
        * For comparing date, use date object
        */
        _compareVal : function (val1, val2, checkEqual) {
            if(!val1 || !val2) {
                return false;
            }

            if(checkEqual) {
                return val1 >= val2;
            } else {
                return val1 > val2;
            }
        }
    });

    //Special handling for IE.
    if ($.browser.msie || $.browser.mozilla) {
        XfaUtil.prototype.$css = function (elem, stylesObj) {
            $(elem).css(stylesObj);
        }
    }
})(_, $, xfalib);
/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/



(function (_, $, xfalib) {
    xfalib.ut.Utilities = {

        isIE11: function () {
            return !!navigator.userAgent.match(/Trident.*rv\:11\./);
        },

        checkMinMozillaVersion: function (version) {
            return (!this.isIE11() && $.browser.mozilla && parseInt($.browser.version) >= version);
        },

        getObjectFromKeyValueStringList: function (list) {
            var key, value, object = {}, tempArray;
            _.each(list, function (keyValuePair, index) {
                tempArray = keyValuePair.split("=");
                if (tempArray && tempArray.length > 1) {
                    object[tempArray[0]] = tempArray[1];
                }
            });
            return object;
        },

        _getNameWithoutMarker: function (fileName) {
            var markerIndex = fileName.indexOf("__afAttachment__");
            if (markerIndex !== -1) {
                fileName = fileName.substring(markerIndex + "__afAttachment__".length, fileName.length);
            }
            return fileName;
        },

        /*
         * This is to check support of multiple files selection in one add new dialog
         */
        _isDataContainerSupported : function () {
            try {
                var dataContainer = new DataTransfer() || (new ClipboardEvent("")).clipboardData;
                if (dataContainer && dataContainer.items) {
                    return true;
                }
            } catch(err) {
                // if err comes then dataContainer is not supported
            }
            return false;
        }
    };
})(_, $, xfalib);
/**
 * @package xfalib.ut.Scanner
 * @fileOverview helper class to scan over a string.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel:{_str: String}}
 */

(function(_,xfalib){
    var Scanner = xfalib.ut.Scanner = xfalib.ut.Class.extend({

        initialize: function() {
            this._pos = 0;
        },

        isEOF : function(){
            return (this.jsonModel._str.length <= this._pos);
        },

        peek : function(){
            return (this.isEOF()) ? null : this.jsonModel._str.charAt(this._pos);
        },

        optionalConsumeChar : function(aChar){
            if(this.jsonModel._str.charAt(this._pos) == aChar){
                this._pos++;
                return aChar;
            }else{
                return null;
            }
        },

        /**
         * Gets next char ignore quoted string.
         *    |
         *   abc returns c.
         *     |
         *   abc'de'f returns f.
         * @param aChar
         */
        getNCharIQS : function(){
            this._pos++;
            if(this.jsonModel._str.length <= this._pos){
                var current = this.jsonModel._str.charAt(this._pos);
                if(current != '\''){
                    return current;
                }else{
                    if(moveNextExpectedChar('\'')){
                        return this.jsonModel._str.charAt(this._pos);
                    }
                }
            }
            return null;
        },

        moveNextExpectedChar : function(aChar){
            this._pos++;// currently point to '
            while(this._pos< this.jsonModel._str.length && this.jsonModel._str.charAt(this._pos) != aChar){
                this._pos++;
            }
            return this._pos < this.jsonModel._str.length;
        },

        readInteger : function(len){
            if(this.pos+len >this.jsonModel._str.length){
                return null;
            }
            var integer = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._str,this._pos,len);
            this._pos+=len;
            return integer;
        }
    });

    Scanner.lookupNext = function(pat, patPos, filter){
        var patLen = pat.length;
        if(patPos >= patLen){
            return null;
        }

        var token = {};
        token.startPos = patPos;

        var firstChar = pat.charAt(patPos);
        var patValid = false;
        //
        if (firstChar == '\''){
            for (var i = patPos+1; i < patLen;i++ ){
                var chr = pat.charAt(i);
                if(chr =='\''){
                    token.type=1;
                    token.len = i - patPos + 1;
                    patValid = true;
                    break;
                }
            }

        }else if( ('a' <= firstChar && firstChar <= 'z' || 'A' <= firstChar && firstChar <= 'Z') || filter.call(null, firstChar)){
            var endPos = patLen;//end is exclusive
            for (var i = 1; patPos+i < patLen;i++ ){
                if(pat.charAt(patPos+i)!=firstChar){
                    endPos = patPos+i;
                    break;
                }
            }
            token.type=2;
            token.len = endPos - patPos;
            token.patChar = firstChar;
            token.patPos = patPos;
            patValid = true;
        }else{
            if (firstChar == '?' || firstChar == '+' || firstChar == '*') {
                token.type=3;
                token.len = 1;
            }else{
                token.type=4;
                token.len = 1;
            }
            patValid = true;
        }
        if(patValid){
            return token;
        }else{
            throw "Picture is invalid.";
        }
    }
})(_,xfalib);


/**
 * @package xfalib.ut.PictureFmt
 * @fileOverview The file defines methods to parse and format data
 * according to XFA picture patterns.
 * @version 0.0.1
 */
(function(_,xfalib) {

    var PictureFmt = xfalib.ut.PictureFmt = function() {};
    PictureFmt.DatePicturePattern =  /^date(?:\([a-zA-Z]*_[a-zA-Z]*\))?\{([\w\W]*?)\}$/;
    PictureFmt.TimePicturePattern =  /^time(?:\([a-zA-Z]*_[a-zA-Z]*\))?\{([\w\W]*?)\}$/;
    PictureFmt.TextPicturePattern =  /^text\{([\w\W]*?)\}$/;
    PictureFmt.NumPicturePattern =  /^num\{([\w\W]*?)\}$/;

    /**
     * Parses a given data source according to the given picture.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {object}
     */
    PictureFmt.parse  = function(sSource, sPicture,sLocale){
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});

        var match = PictureFmt.DatePicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.parseDate(sSource, match[1]);
        }
        match = PictureFmt.TimePicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.parseTime(sSource, match[1]);
        }
        match = PictureFmt.TextPicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.parseText(sSource, match[1]);
        }
        match = PictureFmt.NumPicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.parseNumeric(sSource, match[1]);
        }
        throw "Invalid picture clause "+sPicture;
    };

    /**
     * Formats a given data source according to the given picture.
     * @param date {object}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.format  = function(sSource, sPicture, sLocale,bRelaxed,bFormatNumberFromasDefaultPC){
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});

        var match = PictureFmt.DatePicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.formatDate(sSource, match[1]);
        }
        match = PictureFmt.TimePicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.formatTime(sSource, match[1]);
        }
        match = PictureFmt.TextPicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.formatText(sSource, match[1],bRelaxed);
        }
        match = PictureFmt.NumPicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.formatNumeric(sSource, match[1],sLocale,bRelaxed,bFormatNumberFromasDefaultPC);
        }
            throw "Invalid picture clause "+sPicture;
    };

    /**
     * Checks if a given data source is formatted according to the given picture.
     * @param date {object}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {boolean}
     */
    PictureFmt.formatTest = function (sSource, sPicture, sLocale, bRelaxed, bFormatNumberFromasDefaultPC) {
        var formattedData;
        try {
            formattedData = PictureFmt.format(sSource, sPicture, sLocale, bRelaxed, bFormatNumberFromasDefaultPC);
        }catch(e) {
            return false;
        }

        if(!_.isString(formattedData)) {
            return false;
        } else {
            var parsedData;
            try {
                parsedData = PictureFmt.parse(formattedData, sPicture, sLocale);
            } catch (e) {
                return false;
            }
            if(!_.isString(parsedData) && parsedData !== formattedData) {
                return false;
            }
        }
        return true;
    };

    /**
     * Parses a given data source according to the given date picture
     * under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.parseDate  = function(sSource, sPicture,sLocale){
        var picRegexp = PictureFmt.DatePicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.parseDate(sSource, match[1]);
        }else{
            return PictureEngine.parseDate(sSource, sPicture);
        }
    };


    /**
     * Formats a given data source according to the given date picture
     * * under the given sLocale.
     * @param date {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.formatDate  = function(date, sPicture, sLocale){
        var picRegexp =  PictureFmt.DatePicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.formatDate(date, match[1]);
        }else{
            return PictureEngine.formatDate(date, sPicture);
        }
    };

    /**
     * Parses a given data source according to the given date picture
     * under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {date}
     */
    PictureFmt.parseTime  = function(sSource, sPicture,sLocale){
        var picRegexp = PictureFmt.TimePicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.parseTime(sSource, match[1]);
        }else{
            return PictureEngine.parseTime(sSource, sPicture);
        }
        return null;
    };


    /**
     * Formats a given data source according to the given date picture
     * * under the given sLocale.
     * @param date {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.formatTime  = function(date, sPicture, sLocale){
        var picRegexp =  PictureFmt.TimePicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.formatTime(date, match[1]);
        }else{
            return PictureEngine.formatTime(date, sPicture);
        }
    };

    /**
     * Parses a given data source according to the given text picture
     * under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.parseText  = function(sSource, sPicture,sLocale){
        var picRegexp = PictureFmt.TextPicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.parseText(sSource, match[1]);
        }else{
            return PictureEngine.parseText(sSource, sPicture);
        }
    };

    /**
     * Formats a given data source according to the given text picture
     *  under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.formatText  = function(sSource, sPicture, sLocale,bRelaxed){
        var picRegexp =  PictureFmt.TextPicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.formatText(sSource, match[1],bRelaxed);
        }else{
            return PictureEngine.formatText(sSource, sPicture,bRelaxed);
        }
        return null;
    };

    /**
     * Parses a given data source according to the given numeric picture
     * under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.parseNumeric  = function(sSource, sPicture,sLocale){
        var picRegexp = PictureFmt.NumPicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.parseNumeric(sSource, match[1]);
        }else{
            return PictureEngine.parseNumeric(sSource, sPicture);
        }
        return null;
    };

    /**
     * Formats a given data source according to the given numeric picture
     *  under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.formatNumeric  = function(sSource, sPicture, sLocale){
        var picRegexp =  PictureFmt.NumPicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.formatNumeric(sSource, match[1]);
        }else{
            return PictureEngine.formatNumeric(sSource, sPicture);
        }
    };




    /**
     * Parses a given data source according to the given datetime picture
     * under the given sLocale.
     * @param sSource {string}
     *            the source data.
     * @param sPicture {string}
     *            the datetime picture.
     * @param sDateMask {string}
     *            the date sub-picture.
     * @param sTimeMask {string}
     *            the time sub-picture.
     * @param sLocale
     *            the locale name.
     *
     */
    PictureFmt.parseDateTime  = function(sSource, sPicture, sDateMask, sTimeMask, sLocale){

    };
    /**
     * Formats a given data source according to the given datetime picture
     * under the given locale.
     *
     * @param sSource {string}
     *            the source data.
     * @param sPicture {string}
     *            the datetime picture.
     * @param sDateMask {string}
     *            the date sub-picture.
     * @param sTimeMask {string}
     *            the time sub-picture.
     * @param sLocale {string}
     *            the locale name.
     */
    PictureFmt.formatDateTime  = function(sSource, sPicture, sDateMask, sTimeMask, sLocale){

    };

})(_,xfalib);
/**
 * @package xfalib.ut.PictureUtils
 * @fileOverview The file defines static utilities methods.
 * @version 0.0.1
 */

(function(_,xfalib){
    var PictureUtils = xfalib.ut.PictureUtils = function() {}

    PictureUtils.padding = function(number, digits, isFw, zero){
        var leading = ["0","00","000","0000"];
        var numStr = leading[digits-1] + number;
        return numStr.slice(- digits);
    };

    PictureUtils.parseIntAggressive = function(dateString, startPos,len){
        var result = new Object();
        var parsedNum = 0; //The number value parsed from dateString
        var parsedLen = -1; //How many chars parsed according to this pattern;
        for(var idx=0; idx<len && (startPos + idx) < dateString.length; idx++){
            var chr = dateString.charAt(startPos + idx);
            if(chr >='0' && chr <='9'){
                parsedNum = parsedNum *10 + (chr- '0');
            }else{
                parsedLen = idx;
                break;
            }
        }
        if(parsedLen == -1) {
            parsedLen = len;
        }
        result.value = parsedNum;
        result.len = parsedLen;
        return result;
    };

    PictureUtils.parseIntExact = function(dateString, startPos,len){
        var result = 0;
        PictureUtils.assert(startPos+ len <= dateString.length, "mismatch");
        for(var idx=0; idx<len ; idx++){
            var chr = dateString.charAt(startPos + idx);
            if(chr >='0' && chr <='9'){
                result = result *10 + (chr- '0');
            }else{
                throw "unexpected currentChar in PictureUtils.parseInt";
            }
        }
        return result;
    };

    PictureUtils.isDigit = function(chr){
        return /[0-9]/.test(chr) ;
    };

    PictureUtils.inString = function(chr,aString){
        return (aString.indexOf(chr) >=0) ;
    };


    var regExpIsLetter = /[\u0041-\u005a\u0061-\u007a\u00aa-\u00aa\u00b5-\u00b5\u00ba-\u00ba\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u0236\u0250-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ee-\u02ee\u037a-\u037a\u0386-\u0386\u0388-\u038a\u038c-\u038c\u038e-\u03a1\u03a3-\u03ce\u03d0-\u03f5\u03f7-\u03fb\u0400-\u0481\u048a-\u04ce\u04d0-\u04f5\u04f8-\u04f9\u0500-\u050f\u0531-\u0556\u0559-\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0621-\u063a\u0640-\u064a\u066e-\u066f\u0671-\u06d3\u06d5-\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u06fc\u06ff-\u06ff\u0710-\u0710\u0712-\u072f\u074d-\u074f\u0780-\u07a5\u07b1-\u07b1\u0904-\u0939\u093d-\u093d\u0950-\u0950\u0958-\u0961\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2-\u09b2\u09b6-\u09b9\u09bd-\u09bd\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e-\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd-\u0abd\u0ad0-\u0ad0\u0ae0-\u0ae1\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d-\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71-\u0b71\u0b83-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c-\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb5\u0bb7-\u0bb9\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c60-\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd-\u0cbd\u0cde-\u0cde\u0ce0-\u0ce1\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d28\u0d2a-\u0d39\u0d60-\u0d61\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd-\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32-\u0e33\u0e40-\u0e46\u0e81-\u0e82\u0e84-\u0e84\u0e87-\u0e88\u0e8a-\u0e8a\u0e8d-\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5-\u0ea5\u0ea7-\u0ea7\u0eaa-\u0eab\u0ead-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ebd\u0ec0-\u0ec4\u0ec6-\u0ec6\u0edc-\u0edd\u0f00-\u0f00\u0f40-\u0f47\u0f49-\u0f6a\u0f88-\u0f8b\u1000-\u1021\u1023-\u1027\u1029-\u102a\u1050-\u1055\u10a0-\u10c5\u10d0-\u10f8\u1100-\u1159\u115f-\u11a2\u11a8-\u11f9\u1200-\u1206\u1208-\u1246\u1248-\u1248\u124a-\u124d\u1250-\u1256\u1258-\u1258\u125a-\u125d\u1260-\u1286\u1288-\u1288\u128a-\u128d\u1290-\u12ae\u12b0-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0-\u12c0\u12c2-\u12c5\u12c8-\u12ce\u12d0-\u12d6\u12d8-\u12ee\u12f0-\u130e\u1310-\u1310\u1312-\u1315\u1318-\u131e\u1320-\u1346\u1348-\u135a\u13a0-\u13f4\u1401-\u166c\u166f-\u1676\u1681-\u169a\u16a0-\u16ea\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7-\u17d7\u17dc-\u17dc\u1820-\u1877\u1880-\u18a8\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1d00-\u1d6b\u1e00-\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59-\u1f59\u1f5b-\u1f5b\u1f5d-\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe-\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071-\u2071\u207f-\u207f\u2102-\u2102\u2107-\u2107\u210a-\u2113\u2115-\u2115\u2119-\u211d\u2124-\u2124\u2126-\u2126\u2128-\u2128\u212a-\u212d\u212f-\u2131\u2133-\u2139\u213d-\u213f\u2145-\u2149\u3005-\u3006\u3031-\u3035\u303b-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312c\u3131-\u318e\u31a0-\u31b7\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fa5\ua000-\ua48c\uac00-\ud7a3\uf900-\ufa2d\ufa30-\ufa6a\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e-\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]/

    /**
     * TODO Implement method equivalent to Character.isLetter.
     */
    PictureUtils.isLetter = function(chr){
        return regExpIsLetter.test(chr);
    };

    PictureUtils.isLetterOrDigit = function(chr){
        return this.isLetter(chr) || this.isDigit(chr);
    };

    /**
     * Scan this string for the first character in the given set. Similar to
     * strcspn().
     *
     * @param src{String}
     *            the string to scan
     * @param sSkip{String}
     *            the characters to scan for
     * @param nOffset{number}
     *            the position where to start the scan. Default = 0.
     * @return The position, relative to nOffset, for the first character found
     *         in the given set
     */
    PictureUtils.skipUntil = function(srcStr, sSkip, nOffset) {
        var nCharsSkipped = nOffset;

        // starting at the offset position, scan the characters in this string
        // until it matches one of the characters in the given set.
        while (nCharsSkipped < srcStr.length) {
            var i = nCharsSkipped;
            if (sSkip.indexOf(srcStr.charAt(i++)) >= 0)
                break;
            nCharsSkipped = i;
        }

        return nCharsSkipped - nOffset;
    };

    PictureUtils.matchString = function(str, startPos, target){
        if(startPos + target.length > str.length){
            return false;
        }else{
            for(var idx = 0; idx<target.length; idx++){
                if(target.charAt(idx) != str.charAt(startPos + idx)) return false;
            }
            return true;
        }
    };

    PictureUtils.assert = function(condition, message){
        if(!condition){
            throw message;
        }
    };

    PictureUtils.getLocaleObject = function(locale,property) {
        if(locale !== null && xfalib.runtime.xfa) {
            return xfalib.runtime.xfa._getLocaleSymbols(locale, property);
        } else {
            return xfalib.ut.XfaUtil.prototype.getDefaultLocaleProperty(property)
        }
    }

    PictureUtils.getHashOfLocaleObject = function(locale,property) {
          if(!PictureUtils.getHashOfLocaleObject[locale+"_"+property]) {
              var hashObj = {};
              _.each(PictureUtils.getLocaleObject(locale,property), function(val) {
                  var sVal = (val+"").toLowerCase();
                  var hash = 0;
                  for(var i =0;i<sVal.length;i++) {
                      hash+=(i+1)*sVal.charCodeAt(i)
                  }
                  hashObj[hash] = hashObj[hash] || [];
                  hashObj[hash].push(sVal);
              })
              PictureUtils.getHashOfLocaleObject[locale+"_"+property] = hashObj;
          }
          return PictureUtils.getHashOfLocaleObject[locale+"_"+property]
    }

    PictureUtils.convertNumberToLocale = function(locale,number) {
        var zero = PictureUtils.getLocaleObject(locale,"numberSymbols.zero");
        var zeroCode = zero.charCodeAt(0);
        number += "";
        var newNumber = [];
        for(var i = 0;i < number.length;i++) {
            newNumber.push(String.fromCharCode(zeroCode + parseInt(number.charAt(i))));
        }
        return newNumber.join("");
    }

    PictureUtils.parsePictureClause = function (clause){
        if(clause === null || clause === undefined) {
            return [];
        }
        var insidePattern = false,
            insideQuote=false,
            insideLocale = false,
            locale = "",
            type = "",
            pattern = "",
            flag = false,
            currentChar = "",
            result = [],
            matchType = /^num$|^text$|^date$/,
            matchLocale = /^[a-zA-Z]*_[a-zA-Z]*$/,
            i = 0,
            bracketOpenCount = 0;
        for(;i<clause.length;i++) {
            currentChar = clause.charAt(i);
            if(insideQuote && currentChar !== "'") {
                pattern += currentChar;
                continue;
            }
            switch(currentChar) {
               case "'":
                   if(!insidePattern) {
                       // ' is not allowed except insidePattern
                       return null;
                   }
                   insideQuote = !insideQuote;
                   pattern += currentChar;
                   break;
               case "{":
                    if(insidePattern || insideLocale || type === "") {
                        // { is not allowed insidePattern or insideLocale
                        return null;
                    }
                   insidePattern = true;
                    break;
                case "}":
                    if(!insidePattern || (insideLocale && pattern === "") || type === "") {
                        // { is allowed only insidePattern and not insideLocale
                        return null;
                    } else {
                        bracketOpenCount = 0;
                        insidePattern = false;
                        if(matchType.exec(type) === null) {
                            return null;
                        }
                        if(locale !== "" && matchLocale.exec(locale) === null) {
                            return null;
                        }
                        result.push({
                            category: type,
                            mask: pattern,
                            locale: locale
                        })
                    }
                    break;
                case "|":
                    if(type === "" || insidePattern || insideLocale) {
                        return null;
                    } else {
                        type = pattern = locale = "";
                        insidePattern = insideLocale = false;
                    }
                    break;
                case "(" :
                    if(type === "" || bracketOpenCount === 1) {
                        // ( is not allowed inside Locale
                        return null;
                    } else {
                        if(!insidePattern) {
                            insideLocale = true;
                        } else {
                            pattern += currentChar;
                        }
                        bracketOpenCount++;
                    }
                    break;
                case ")" :
                    if((!insideLocale && !insidePattern) || bracketOpenCount === 0) {
                        return null;
                    } else {
                        if(insidePattern) {
                            pattern += currentChar;
                        }
                        insideLocale = false;
                        bracketOpenCount--;
                    }
                    break;
                default:
                    if(insidePattern) {
                        pattern += currentChar;
                    } else if(insideLocale) {
                        locale += currentChar;
                    } else if(type !== "" && (pattern !== "" || locale !== "")){
                        return null;
                    } else {
                        type += currentChar;
                    }
                    break;
           }
       }
       if(insidePattern || insideLocale || insideQuote || bracketOpenCount !== 0) {
           return null;
       }
       return result;
    }

})(_,xfalib);

/**
 * @package xfalib.ut.VisitorBase
 * @import xfalib.ut.Class
 * @fileOverview Base class for visitor
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String}}
 */

(function(_,xfalib) {
    var VisitorBase = xfalib.ut.VisitorBase = xfalib.ut.Class.extend({
        consume : function(token){
            switch (token.type)
            {
                case 1:
                    this.consumeStringLiteral(token);
                    break;
                case 2:
                    this.consumeSubPattern(token);
                    break;
                case 3:
                    this.consumeStringWildCard(token);
                    break;
                case 4:
                    this.consumeCharLiteral(token);
                    break;
            }
        },
        acceptPatternChar : function(chr){
            return false;
        },
        getPicture : function(){
            return this.jsonModel._sPicture;
        },
        abstractMethod : function(){
            throw "Not implemented";
        },
        consumeStringWildCard : this.abstractMethod,
        consumeStringLiteral: this.abstractMethod,
        consumeCharLiteral: this.abstractMethod,
        consumeSubPattern: this.abstractMethod,
        getResult: this.abstractMethod
    });
})(_,xfalib);

/**
 * @package xfalib.ut.NumPictureDesc
 * @import xfalib.ut.Class
 * @fileOverview Pre-process Numeric Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String}}
 */

(function(_,xfalib){
    var NumPictureDesc = xfalib.ut.NumPictureDesc = xfalib.ut.Class.extend({

        initialize: function() {
            this.hasRadix = false;
            this.hasExpon = false;
            this.hasSign = false;
            this.hasPercent = false;
            this.fracDigit = 0;
            this.intDigit = 0;

            this._mbLeftParenSeen = false;
            this._mbRightParenSeen = false;
            this._compactPattern();
            this._xlatePattern();
            NumPictureDesc._super.initialize.call(this);
        },
        
        getPicture : function(){
            return this.jsonModel._sPicture;
        },

        _match2Char : function (char1, char2, idx){
            if(idx+1 < this.jsonModel._sPicture.length){
                return (this.jsonModel._sPicture.charAt(idx) ==char1 && this.jsonModel._sPicture.charAt(idx+1) ==char2);
            }else{
                return false;
            }
        },

        _xlatePattern : function(){
            var patPos = 0;
            for(var token = xfalib.ut.Scanner.lookupNext(this.jsonModel._sPicture, patPos, this._acceptPatternChar); token != null;  ){
                this._consume(token);
                patPos = patPos + token.len;
                token = xfalib.ut.Scanner.lookupNext(this.jsonModel._sPicture, patPos, this._acceptPatternChar);
            }
        },
        
        _compactPattern : function(){
            var buf = new Array();
            for(var index =0, len = this.jsonModel._sPicture.length; index <len; index++){
                if(this._match2Char('D','B',index)){
                    buf.push('D');
                    index++;
                }else if(this._match2Char('d','b',index)){
                    buf.push('d');
                    index++;
                }else if(this._match2Char('C','R',index)){
                    buf.push('C');
                    index++;
                }else if(this._match2Char('c','r',index)){
                    buf.push('c');
                    index++;
                }else{
                    buf.push(this.jsonModel._sPicture.charAt(index));
                }
            }
            this.jsonModel._sPicture = buf.join("");
        },

        _acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "(%$,.)89BCDERSVZbcdrsvzt");
        },

        _consume : function(token){
            if(token.type == 2){
                this._subConsume(token.patChar, token.len);
            }// else not a pattern
        },

        _subConsume : function(chr, chrCnt){
            switch (chr) {
                case'E' :
                    if (chrCnt > 1 || this.hasExpon || (this.fracDigit + this.intDigit)==0)
                        throw "Illegal Numeric Picture: more than one Expon";
                    this.hasExpon = true;
                    break;
                case '(':
                    if (chrCnt > 1 || this._mbLeftParenSeen	|| this.fracDigit + this.intDigit >0 )
                        throw "Illegal Numeric Picture:  ()";
                    this._mbLeftParenSeen = true;
                    break;

                case ')':
                    if (chrCnt > 1 || ! this._mbLeftParenSeen || this._mbRightParenSeen)
                        throw "Illegal Numeric Picture:  ()";
                    this._mbRightParenSeen = true;
                    if(this.fracDigit + this.intDigit >0) this.hasSign = true;
                    break;
                case 'S':
                case 's':
                case 'C': //CR
                case 'c': //cr
                case 'D': //DB
                case 'd': //db
                    this.hasSign = true;
                    break;
                case '%' :
                    this.hasPercent = true;
                    break;
                case '.':
                case 'V':
                case 'v':
                    if (chrCnt > 1 || this.hasRadix)
                        throw "Illegal Numeric Picture: too many vV.";
                    this.hasRadix = true;
                    this._mbFracStartSeen = true;
                    break;
                case '8' :
                case '9' :
                case 'Z':
                case 'z':
                    if (this.hasRadix){
                        this.fracDigit += chrCnt;
                    } else{
                        this.intDigit += chrCnt;
                    }
                    break;
            }
        },

        parseNumberInfo : function(msText){
            var text=msText,
                num = Number(text),
                negative = false
            if(num < 0){
                negative = true;
                num = -num;
                text = text.replace("-","");
            }
            if(this.hasPercent){
                num *= 100;
                text = ""+num;
            }
            var shift = 0;
            if(this.hasExpon){
                var threshold = Math.pow(10,this.intDigit);
                if(num < threshold){
                    while(num*10 < threshold) {
                        num *= 10;
                        shift--;
                    }
                }else{
                    while(num > threshold){
                        num /= 10;
                        shift++;
                    }
                }
                text = num+"";
            }
            var radixPos = text.indexOf(".", 0),
                fractionDigit = radixPos<0 ? 0 : text.length - radixPos - 1

            if(this.fracDigit < fractionDigit) {
                num = num.toFixed(this.fracDigit);
                text = num +""
            }

            if(text.indexOf("0") == 0 && msText.indexOf("0") != 0) {
                text = text.substring(1);
            }

            radixPos = text.indexOf(".", 0)
            var integerDigit = radixPos < 0 ? text.length : radixPos,
                offset = this.intDigit - integerDigit

            if(offset <0 ){
                throw "Exit: most significant " + offset +" digit lost";
            }
            return {
                "integerDigit" : integerDigit,
                "radixPos" : radixPos ,
                "fractionDigit" :  radixPos<0 ? 0 : text.length - radixPos - 1,
                "msText" : text,
                "shift" : shift,
                "isNegative" : negative,
                "padding" :offset
            };
        }
    });

    NumPictureDesc.gsDB = "DB";
    NumPictureDesc.gsCR = "CR";
    NumPictureDesc.gsE = "E";
    NumPictureDesc.gsDSP = "  ";
    NumPictureDesc.gsSSP = " ";

})(_,xfalib);











    /**
 * @package xfalib.ut.TimeInfo
 * @import xfalib.ut.Class
 * @fileOverview A wrapper class for date related information.
 * @version 0.0.1
 */

/**
 * @constructor
 */
(function(_,xfalib){
    var TimeInfo = xfalib.ut.TimeInfo = xfalib.ut.Class.extend({

        initialize: function() {
            this.mHourOfMeriDiem = -1;
            this.mHourOfDay = -1;
            this.mMinuteOfHour = -1;
            this.mSecondOfMinute = -1;
            this.mThousandthOfSecond = -1;
        },

        getISOTime : function(){
            var timeStr = "";
            if(this.mThousandthOfSecond>0){
                timeStr = "-" + this.formatNum(this.mThousandthOfSecond,3);
            }
            if(this.mSecondOfMinute>0 || timeStr!=""){
                timeStr = this.formatNum(this.mSecondOfMinute,2)+timeStr;
                timeStr = ":"+timeStr;
            }
            if(this.mMinuteOfHour>0 || timeStr!=""){
                timeStr = this.formatNum(this.mMinuteOfHour,2)+timeStr;
                timeStr = ":"+timeStr;
            }
            timeStr = this.formatNum(this.mHourOfDay,2) + timeStr;

            return timeStr;
        },

        formatNum : function(num, digits){
            if(num<0){
                num = 0;
            }
            return xfalib.ut.PictureUtils.padding(num, digits);
        },

        getDate : function(){
            var date = new Date();
            this.setTime(date);
            return date;
        },

        setTime : function(date){
            date.setHours(this.mHourOfDay);
            date.setMinutes(this.mMinuteOfHour);
            date.setSeconds(this.mSecondOfMinute);
            date.setMilliseconds(this.mThousandthOfSecond);
        }
    });

    /**
     *
     * <p>Valid ISO8601/XFA time strings are in any one
     * of the following time patterns:
     * <ul>
     * <li> HH[MM[SS[.FFF][z]]]
     * <li> HH[MM[SS[.FFF][+HH[MM]]]]
     * <li> HH[MM[SS[.FFF][-HH[MM]]]]
     * <li> HH[:MM[:SS[.FFF][z]]]
     * <li> HH[:MM[:SS[.FFF][+HH[:MM]]]]
     * <li> HH[:MM[:SS[.FFF][-HH[:MM]]]]
     * </ul>
     */
    TimeInfo.Parse = function(isoDateStr, locale){
        var scanner = new xfalib.ut.Scanner({jsonModel:{_str:isoDateStr}});
        var hours = scanner.readInteger(2);
        var minitues = -1;
        if(!scanner.isEOF()){
            scanner.optionalConsumeChar(':');
            minitues = scanner.readInteger(2);
        }
        var seconds = -1;
        if(!scanner.isEOF()){
            scanner.optionalConsumeChar(':');
            seconds = scanner.readInteger(2);
        }
        var milliseconds = -1;
        if(!scanner.isEOF()){
            scanner.optionalConsumeChar('-');
            milliseconds = scanner.readInteger(3);
        }
        //TODO timezone
        var info = new xfalib.ut.TimeInfo();
       TimeInfo.setPropertyIfNotNull(info,hours,"mHourOfDay");
       TimeInfo.setPropertyIfNotNull(info,minitues,"mMinuteOfHour");
       TimeInfo.setPropertyIfNotNull(info,seconds,"mSecondOfMinute");
       TimeInfo.setPropertyIfNotNull(info,milliseconds,"mThousandthOfSecond");
        return info;
    };

    /**
     *
     * static method
     */
    TimeInfo.setPropertyIfNotNull = function(object, value, proName){
        if(value!=null){
            var d = Number(value);
            if(!isNaN(d)){
                object[proName] = d;
            }
        }
    };

})(_,xfalib);
/**
 * @package xfalib.ut.DateInfo
 * @import xfalib.ut.Class
 * @fileOverview A wrapper class for date related information.
 * @version 0.0.1
 */

/**
 * @constructor
 */

(function(_,xfalib) {
    var DateInfo = xfalib.ut.DateInfo = xfalib.ut.Class.extend({

        initialize: function(options) {
            if (options && !options.isParsingCall ) { // skip setting internal values when called while parsing date formats
                this.date = new Date();
                this._year = this.date.getFullYear();
                this._month = this.date.getMonth() + 1;
                this._day = this.date.getDay();
            }
            DateInfo._super.initialize.call(this);
        },

        formatNum : function(num, digits){
            if(num<0)
                num = 0;
            return xfalib.ut.PictureUtils.padding(num, digits);
        },

        getDate : function(){
            return this.date;
        },
        setDate : function() {
          this.date = new Date(this._year,this._month-1,this._day)
        },
        getISODate : function(){
            var isoDate = [];

            isoDate.push(this.formatNum(this._year, 4));
            isoDate.push("-");
            isoDate.push(this.formatNum(this._month, 2));
            isoDate.push("-");
            isoDate.push(this.formatNum(this._day, 2));

            return isoDate.join("");
        },

        year : function(y) {
            if(y && y > 0 && y <= 9999)
                this._year = y;
            else
                throw "undefined year";
        },

        month : function(m) {
            if(m && m>0 && m < 13) {
               this._month = m;
            }
            else
                throw "Invalid month " + m;
        },

        _leapYear : function() {
            var year = this._year;
            return year % 400 == 0 || (year % 100 != 0 && year % 4 == 0);
        },

        _maxDate : function(m) {
              if(this._leapYear() && m == 2)
                 return 29;
              else return DateInfo.dates[m-1];
        },

        day : function(d) {
            if(d && d > 0 && d <= this._maxDate(this._month || 0))
                this._day = d;
            else
                throw "Invalid Date "+ d + " for the month "+(this._month);
        },

        validate : function(y, m, d) {
                this.year(y);
                this.month(m);
                this.day(d);
        }
    });

    DateInfo.ParseIsoString = function(isoDateStr, locale){
		var isDateRegexp = /^(\d{4})(?:-?(\d{1,2})(?:-?(\d{1,2}))?)?(?:T((\d{2}):(\d{2}):(\d{2}))Z)?$/;
        var match = isDateRegexp.exec(isoDateStr);
        if(match && match.length >= 4){
            var dateInfo = new DateInfo();
            var date = new Date(isoDateStr);
            // TODO - check if date is invalid.
            if(match[4] && date != null) { // if time is available then use date object for conversion otherwise use previous approach to support invalid date like 2012-10-101, 2010-02-29 etc for RTC CQ-4201274
                dateInfo.year(date.getFullYear());
                dateInfo.month(date.getMonth()+1);
                dateInfo.day(date.getDate());
            } else {
                try {
                    dateInfo.year(Number(match[1]));
                    dateInfo.month(Number(match[2]));
                    dateInfo.day(Number(match[3]));
                } catch(e) {
                    return null;
                }
            }
            dateInfo.setDate();
            return dateInfo;
        }
        return null;
    };

    DateInfo.Parse = function(dateStr, locale, validateWithDefaultPatterns){
        locale = locale || "en_US";
        var patterns = xfalib.ut.PictureUtils.getLocaleObject(locale,"datePatterns"),
            isoDate = this.ParseIsoString(dateStr, locale);
        if(!_.isEmpty(isoDate)) {
            return isoDate;  // in case edit pattern is present, it'll be parsed by the widget during input and return an iso date string.
        }
        //if edit pattern is present then don't try to match it from default locale patterns.
        if(validateWithDefaultPatterns === false){
            _.find(patterns, function(pattern) {
                try {
                    isoDate = xfalib.ut.PictureFmt.parseDate(dateStr,pattern,locale);
                    return true;
                } catch(exception) {
                    return false;
                }
            });
        }
        isoDate = isoDate || dateStr;
        return DateInfo.ParseIsoString(isoDate);
    };

    DateInfo.dates = [31,28,31,30,31,30,31,31,30,31,30,31];
    DateInfo.daysOfWeek = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
})(_,xfalib);
/**
 * @package xfalib.ut.PictureEngine
 * @import xfalib.ut.Scanner
 * @fileOverview The file is a facade to assembly all components together.
 * @version 0.0.1
 */
(function(_,xfalib) {

    var PictureEngine = xfalib.ut.PictureEngine = xfalib.ut.Class.extend({

        _lookupNext: xfalib.ut.Scanner.lookupNext,

        MAX_XFA_PREC	: 8,		// Max no. of fractional digits in XFA.
        MAX_DBL_DIG	:18,		// Max no. of significant digits in a double.
        MAX_INT_DIG	:10,		// Max no. of significant digits in an integer.
        MAX_DBL_WIDTH	:15,		// Max width before precision loss in a double.
        INTEGRAL_FMT :  0,
        DECIMAL_FMT : 1,
        CURRENCY_FMT : 2,
        PERCENT_FMT : 3,

        parseDate : function(sSource, sPicture, locale){
            return this._acceptVisitor(new xfalib.ut.DateParsingVisitor({jsonModel:{_sPicture:sPicture,_dataString:sSource,_locale:this.jsonModel.locale}}));
        },

        formatDate : function(dDate, sPicture){
            var validateWithDefaultPatterns = typeof sPicture !== 'undefined';
            var dateInfo = xfalib.ut.DateInfo.Parse(dDate, this.jsonModel.locale, validateWithDefaultPatterns);
            if(dateInfo == null){
                return null;
            }else{
                return this._acceptVisitor(new xfalib.ut.DateFormattingVisitor({jsonModel:{_sPicture:sPicture,_dateInfo:dateInfo,_locale:this.jsonModel.locale}}));
            }
        },

        parseTime : function(sSource, sPicture){
            return this._acceptVisitor(new xfalib.ut.TimeParsingVisitor({jsonModel:{_sPicture:sPicture,_dataString:sSource}}));
        },

        formatTime : function(dDate, sPicture){
            var timeInfo = xfalib.ut.TimeInfo.Parse(dDate, this.jsonModel.locale);
            if(timeInfo == null){
                return null;
            }else{
                return this._acceptVisitor(new xfalib.ut.TimeFormattingVisitor({jsonModel:{_sPicture:sPicture,_timeInfo:timeInfo}}));
            }
        },

        parseText : function(sSource, sPicture){
            return this._acceptVisitor(new xfalib.ut.TextParsingVisitor({jsonModel:{_sPicture:sPicture,_dataString:sSource}}));
        },

        formatText : function(sSource, sPicture,bRelaxed){
            return this._acceptVisitor(new xfalib.ut.TextFormattingVisitor({jsonModel:{_sPicture:sPicture,_text:sSource,relaxed:bRelaxed}}));
        },

        parseNumeric : function(sSource, sPicture){
            var visitor = new xfalib.ut.NumParsingVisitor({jsonModel:{_sPicture:sPicture,_dataString:sSource,_locale:this.jsonModel.locale}}); // TODO : Is locale required
            visitor.parse();
            return visitor.getResult();
        },

       formatNumeric : function(sSource, sPicture,locale,bRelaxed,bFormatNumberFromasDefaultPC){

             var sFormatPicture =sPicture;
             if( bRelaxed && bFormatNumberFromasDefaultPC){
                 sFormatPicture = this.getNumberFormat(sPicture,1, {formatOption: "WITH_GROUPINGS",
                                      "precision"  : this.getNumberPrecision(sSource),
                                    "width"      : sSource.length
                                   });
             }
             return this._acceptVisitor(new xfalib.ut.NumFormattingVisitor({jsonModel:{_sPicture:sFormatPicture,_locale:this.jsonModel.locale},text:sSource}));
        },

        _acceptVisitor : function(visitor){
            this._scanPattern(visitor);
            return visitor.getResult();
        },

        _scanPattern : function(visitor){
            var patPos = 0;
            var sPicture = visitor.getPicture();
            for(var token = this._lookupNext(sPicture, patPos, visitor.acceptPatternChar); token != null;  ){
                visitor.consume(token);
                patPos = patPos + token.len;
                token = this._lookupNext(sPicture, patPos, visitor.acceptPatternChar);
            }
        },

       /**
          * Removes n bytes from this string starting at position nOffset.
         *
          * @param nOffset - start position for the remove
          * @param nLength - the number of characters to remove
          * @return This string
          */

         _swallow : function(sString , nOffset, nLenToSwallow)
         {
             if(_.isEmpty(sString) || nLenToSwallow ==0){
                 return sString;
             }

             if( (nOffset + nLenToSwallow)> sString.length ) {
                 nLenToSwallow = (nOffset + nLenToSwallow) - sString.length;
             }
            var subStr = sString.substr(0,nOffset) + sString.substr(offset + nLenToSwallow);

             return subStr
         },
         /**
         * Replace some portion of one string with another String.
          * @param sString - the String where it has to be replaced.
          * @param sReplacement - the replacement string.
          * @param nOffset - start position for the replacement. Default value = 0.
          * @param nCutLength - the number of bytes to remove from the
          * original string.
          */

         _replaceAll : function(sString ,sReplacement , nOffset ,nCutlength) {
             return sString.substr(0,nOffset) + sReplacement  + sString.substr(nOffset + nCutlength)
         },

         //----------------------------------------------------------------------
         // SkipOver
         //
         // Scan this string for the first byte of the character not in the given set.
         // Similar to strspn().
         //----------------------------------------------------------------------
         _skipOver : function(fromString,sSkip, nOffset)
         {
             // starting at the offset position, scan the characters in this string
             // until it does not match any of the characters in the given set.
            var nCharsSkipped = nOffset;
             var i = 0;
             while (nCharsSkipped < fromString.length)
             {
                 i = nCharsSkipped;
                 if (sSkip.indexOf(fromString[i]) ==-1) {
                     break;
                 }
                 i++;
                 nCharsSkipped = i;
             }

             return nCharsSkipped - nOffset;
         },

         /*
          * Get the numeric format in the given style.
          * @param style in the range of values 0-2,
          * where (0 = integral, 1 = decimal, 2 = currency).
          * @param option in the set of format options:
          */
         getNumberFormat : function(format , style, option)
        {
             if (style < this.INTEGRAL_FMT || this.PERCENT_FMT < style) {
                 style = this.DECIMAL_FMT;
             }

             var sFormat = format;

             //
             // Use any alternate part because they handle negative values.
             //
             var  nBar = 0;
             if ((nBar = sFormat.indexOf('|')) != -1) {
                 sFormat = this._swallow(sFormat, 0, nBar + 1);
             }
             //
             // Determine position of radix (or anything like it)
             // and the replicating part of the pattern, i.e., from
             // the separator to this radix.
            //
             var nDot;
             if ( (nDot = sFormat.indexOf('.')) == -1) {
                 if ((nDot = sFormat.indexOf('v')) == -1) {
                     if ((nDot = sFormat.indexOf('V')) == -1) {
                         if ((nDot = sFormat.indexOf('E')) == -1) {
                             if ((nDot = sFormat.indexOf(' ')) == -1) {
                                 if ((nDot = sFormat.indexOf('%')) == -1) {
                                     nDot = sFormat.length;
                                 }
                             }
                         }
                     }
                 }
             }
             if (nDot) {
                 if (this._skipOver(sFormat,"89zZ", nDot - 1) != 1) {
                     nDot = sFormat.length;
                 }
             }
             var sZZZ;
             var nZed;
             if ( (nZed = sFormat.indexOf("z,")) != -1) {
                 //
                 // Watson 1230768.  Handle locales, like India, that have
                 // pictures with more than one grouping symbol.
                //
                 var nSep = nDot;
                 var nComma;
                 if ((nComma = sFormat.indexOf(',', nZed + 2)) !=-1) {
                    nSep = nComma;
                 }
                 if (nSep > nZed + 2) {
                     sZZZ = Array(nSep - nZed).join('z');
                 }
                 else {
                     sZZZ = Array(1).join('z');
                 }
             }
             else {
                nZed = 0;
             }
             //
             // If non-integral styles Then determine width and precision.
             //
             var nPrec = 0;
             var nWidth = this.MAX_INT_DIG;
             if (style != this.INTEGRAL_FMT) {
                 nPrec = option.precision; // (option >> 8) & 0xff;
                 var trim = ((nPrec & 0x80) == 0);
                 nPrec &= 0x7f;
                 if (nPrec == 0x7f) {
                     nPrec = this._skipOver(sFormat, "89zZ", nDot + 1);
                 }
                 if ((option.width) != undefined) {
                     nWidth = option.width;
                 }
                 else {
                     nWidth = this.MAX_DBL_DIG;
                 }
                 //
                 // Fix for Watson 1229423.  If the locale's format contains
                 // any sign pictures Then widen accordingly.  Also widen if
                 // precision of locale's picture format is greater than requested.
                 //
                 if (sFormat.indexOf('s')!=-1) {
                     nWidth += 1;
                 }
                 if (sFormat.indexOf('(')!=-1) {
                     nWidth += 1;
                 }
                 if (sFormat.indexOf(')') !=-1) {
                     nWidth += 1;
                 }
                var nFmtPrec = this._skipOver(sFormat,"89zZ", nDot + 1);
                 if (0 < nPrec && nPrec < nFmtPrec) {
                     nWidth += nFmtPrec - nPrec;
                 }

                 //
                 // Pare down the precision if the width is big enough to yield
                 // IEEE 754 64-bit double precision errors, which appears to be
                 // anything over 14 significant digits.
                 //
                 if (trim && nPrec > 0 && nWidth > nPrec) {
                     //
                     // Fix for Watson 1211481.  If the given precision is less
                     // than what the locale's format dictates then widen the given
                     // width.
                    //
                     if (nPrec <= sFormat.length - 1 - nDot) {
                         nWidth += sFormat.length - 1 - nDot - nPrec;
                     }
                     for (var i = nWidth - 1; i > this.MAX_DBL_WIDTH; i--) {
                         //
                         // Never pare down the precision below what the locale's
                         // format dictates.
                         //
                         if (nPrec <= sFormat.length - 1 - nDot)
                            break;
                         nPrec--;
                     }
                 }
             }
             //Watson 1483675 - If the locale's format contains
             // a dollar sign or a space then widen accordingly.
             if (style == this.CURRENCY_FMT) {
                 if (sFormat.indexOf('$')!=-1) {
                     nWidth++;
                 }

                 if (sFormat.indexOf(' ')!=-1) {
                     nWidth += 1;
                }
             }

             //
             // If percent style was wanted Then truncate after the percent character.
             //
             if (style == this.PERCENT_FMT) {
                 var nTrim = this._skipOver(sFormat,"89zZ", nDot + 1);
                 sFormat = this._replaceAll(sFormat,"",nTrim,0)
                 //sFormat.Replace(jfString::EmptyString(), nDot + 1, nTrim);

                 //Watson 1483675 - If the locale's format contains
                 // a percent sign then widen accordingly.
                 if (sFormat.indexOf('%')!=-1) {
                     nWidth++;
                 }
             }
             //
             // Else if integral style was wanted Then truncate at the radix character.
             //
             //
             // If integral style was wanted Then truncate at the radix character.
             //
             else if (style == this.INTEGRAL_FMT || nPrec == 0){// && option.formatOption == "WITHOUT_RADIX") {
                 var nTrim = this._skipOver(sFormat,"89zZ", nDot + 1);
                 sFormat = this._replaceAll(sFormat,"",nDot,nTrim+1);
             }
             //
             // Otherwise for decimal and currency styles Do
             // replace fractional 'z' pictures with '8's to requested precision,
             //
             else if (option.formatOption == "WITH_EIGHTS") {
                 var nEight = nDot + 1;
                 while ((nEight =sFormat.indexOf('z'))!=-1) {
                     this._replaceAll(sFormat, '8', nEight,'8'.length);
                 }
                 while (sFormat.Length() - nDot <= nPrec) {
                     sFormat = this._replaceAll(sFormat, "8", nDot + 1, 0);
                 }
             }
             //
             // Or replace fractional '9' pictures with 'z's to requested precision
             // Watson 1322850 - add option to keep nines, previously this function
             // would force frac. digits to be either z's or 8's with no option for 9's.
             //
             else if ((option.formatOption) == "WITH_ZEDS" && !((option.formatOption) == "KEEP_NINES")) {
                 var nNine = nDot + 1;
                 while ((nNine = sFormat.indexOf('9'))!=-1) {
                     this._replaceAll(sFormat, 'z', nNine,1);
                 }
                 while (sFormat.Length() - nDot <= nPrec) {
                     this._replaceAll(sFormat, "z", nDot + 1, 0);
                 }
             }
             //
             // Replicate section from separator to radix to requested width.
             //
             if (!sZZZ) {
                 sZZZ = "z";
             }
            else if ((option.formatOption) == "WITHOUT_GROUPINGS" ) {
                 //
                 // Watson 1230768.  Handle locales, like India, that have
                 // pictures with more than one grouping symbol.
                 //
                 var nComma = nZed + 1 ;
                 this._replaceAll(sFormat, 'z' ,nComma,1);
                 while ( nComma!= -1 && (nComma < nDot)) {
                     nComma = sFormat.indexOf(',');
                     sFormat = this._replaceAll(sFormat,'z',nComma,1);
                 }
             }
             else if ((option.formatOption == "WITH_GROUPINGS")) {
                 sZZZ = this._replaceAll(sZZZ,',',0,1);
                 nWidth += (nWidth + sZZZ.length) / sZZZ.length;
             }
             while (sFormat.length < nWidth) {
                 sFormat = this._replaceAll(sFormat, sZZZ, nZed + 1, 0);
             }
             return sFormat;
         },

         /**
          * Get the decimal precision of the given numeric string.
          * @return the decimal precision or 0 for integral values.
          */
         getNumberPrecision: function(sVal)
         {
             var nRadix = 0;
             var i = -1;
             // Reason for not using the commented line. We are always storing the value in model with . as decimal separator
             // Passing field locale/ browser locale would lead to precision width being zero for non-english locales where
             // decimal separater may be different.
             // var rIndex = xfalib.ut.PictureUtils.getLocaleObject(this.jsonModel.locale,"numberSymbols").decimal;
             // so hardcoding . for now
             var rIndex = ".";
             if( (nRadix = sVal.indexOf(rIndex))!=-1)
             {
                     for(; nRadix <=sVal.length ;nRadix++) {
                         i++;
                     }

                 return i;
             }
             return 0;
          }
    })
})(_,xfalib);
/**
 * @package xfalib.ut.FormattingVisitorBase
 * @import xfalib.ut.VisitorBase
 * @fileOverview Base class for visitor
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String]}
 */

(function(_,xfalib) {
    var FormattingVisitorBase = xfalib.ut.FormattingVisitorBase = xfalib.ut.VisitorBase.extend({

        initialize: function() {
            this._buffer = []; //TODO: ASK Ren where does this _buffer comes from
            FormattingVisitorBase._super.initialize.call(this);
        },

        consumeStringWildCard : function(token){
            //'?' '*' '+
            this._buffer.push(" ");
        },

        consumeStringLiteral : function(token){
            this._buffer.push(this.jsonModel._sPicture.substr(token.startPos+1,token.len-2));
        },

        consumeCharLiteral : function(token){
            this._buffer.push(""+ this.jsonModel._sPicture.charAt(token.startPos));
        }
    })

})(_,xfalib);
/**
 * @package xfalib.ut.ParsingVisitorBase
 * @import xfalib.ut.VisitorBase
 * @fileOverview Base class for visitor
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String,_dataString: String}}
 */

(function(_,xfalib){
    var ParsingVisitorBase = xfalib.ut.ParsingVisitorBase = xfalib.ut.VisitorBase.extend({

        initialize: function() {
            this._strLen = this.jsonModel._dataString.length;
            this._strPos = 0;
            ParsingVisitorBase._super.initialize.call(this);
        },

        consumeStringWildCard : function(token){
            if (chr == '?') {
                if (this._strPos < this._strLen)//&& Character.isDefined(str.charAt(strPos))
                    this._strPos += 1;
            } else if (chr == '+') {
                if (this._strPos >= this._strLen)// || ! Character.isWhitespace(str.charAt(strPos)))
                    throw "Mismatch";
                this._strPos += 1;
                while (this._strPos < this._strLen)// && Character.isWhitespace(str.charAt(strPos)))
                    this._strPos += 1;
            } else if (chr == '*') {
                while (this._strPos < this._strLen)// && Character.isWhitespace(str.charAt(strPos)))
                    this._strPos += 1;
            }

        },

        consumeStringLiteral : function(token){
            for(var offset=0; offset<token.len-2 ;offset++){ //-2, heading and trailing quote
                if(this.jsonModel._sPicture.charAt(token.startPos+offset+1) != this.jsonModel._dataString.charAt(this._strPos+offset)){
                    throw ("Mismatch" + this.jsonModel._sPicture.substr(token.startPos, token.len));
                }
            }
            this._strPos += token.len-2;

        },

        consumeCharLiteral : function(token){
            if(this.jsonModel._sPicture.charAt(token.startPos) == this.jsonModel._dataString.charAt(this._strPos)){
                this._strPos += 1;
            }else{
                throw "Mismatch";
            }
        }
    })
})(_,xfalib);

/**
 * @package xfalib.ut.DateFormattingVisitor
 * @import xfalib.ut.FormattingVisitorBase
 * @fileOverview The file provides formating logic on date pattern characters.
 * @version 0.0.1
 */


/**
 * @constructor
 * @param object {jsonModel: {_sPicture:String,_dateInfo: xfalib.ut.DateInfo}}
 */

(function(_,xfalib) {
    var PictureUtils =  xfalib.ut.PictureUtils;
    var DateFormattingVisitor = xfalib.ut.DateFormattingVisitor = xfalib.ut.FormattingVisitorBase.extend({

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;

            switch (chr) {
                case 'D':
                    var dayOfMonth=this.jsonModel._dateInfo.date.getDate();
                    switch(chrCnt){
                        case 1:
                            break;
                        case 2:
                            dayOfMonth = PictureUtils.padding(dayOfMonth,2);
                            break;
                    }
                    this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,dayOfMonth));
                    break;
                case 'J':

                    //this._mDayOfYear;
                    break;
                case 'M':
                    var monthOfYear = this.jsonModel._dateInfo.date.getMonth();
                    switch(chrCnt){
                        case 1:
                            this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,monthOfYear+1));
                            break;
                        case 2:
                            this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,PictureUtils.padding(monthOfYear+1,2)));
                            break;
                        case 3:
                            var monthNames = PictureUtils.getLocaleObject(this.jsonModel._locale,"calendarSymbols.abbrmonthNames");
                            this._buffer.push(monthNames[monthOfYear]);
                            break;
                        case 4:
                            var monthNames = PictureUtils.getLocaleObject(this.jsonModel._locale,"calendarSymbols.monthNames");
                            this._buffer.push(monthNames[monthOfYear]);
                            break;
                    }

                    break;
                case 'E':
                    var dayOfWeek = this.jsonModel._dateInfo.date.getDay();
                    var dayNames;
                    switch(chrCnt) {
                        case 1:
                            this._buffer.push(dayOfWeek);
                            break;
                        case 3:
                            dayNames =  PictureUtils.getLocaleObject(this.jsonModel._locale,"calendarSymbols.abbrdayNames");
                            this._buffer.push(dayNames[dayOfWeek]);
                            break;
                        case 4:
                            dayNames =   PictureUtils.getLocaleObject(this.jsonModel._locale,"calendarSymbols.dayNames");
                            this._buffer.push(dayNames[dayOfWeek]);
                            break;
                        default:
                            throw "unsupported Picture Clause ";
                    }
                    break;
                case 'e':
                    break;
                case 'G':
                    break;
                case 'Y':

                    var yearOfEra = this.jsonModel._dateInfo.date.getFullYear()
                    switch(chrCnt){
                        case 2:
                            if(yearOfEra>2029 || yearOfEra < 1930){
                                throw "unsupported " + yearOfEra + " by pattern YY";
                            }
                            yearOfEra = PictureUtils.padding(yearOfEra % 100, 2);
                            break;
                        case 4:
                            yearOfEra = PictureUtils.padding(yearOfEra, 4); // 2 digit(0000-9999)
                            break;
                    }
                    this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,yearOfEra));
                    break;
                case 'w':
                    break;
                case 'W':
                    break;
                default: throw "Unsupported pattern";
            }

        },
        /**
         *
         * @override
         */
        getResult : function(){
            return this._buffer.join("");
        }

    });
})(_,xfalib);


/**
 * @package xfalib.ut.TextFormattingVisitor
 * @import xfalib.ut.FormattingVisitorBase
 * @fileOverview Formats a string according to Text Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object { jsonModel:{_sPicture: String, _text: String}}
 */
(function(_,xfalib){
    var TextFormattingVisitor = xfalib.ut.TextFormattingVisitor = xfalib.ut.FormattingVisitorBase.extend({

        initialize: function() {
            this._textPos = 0;
            this._relaxed = typeof this.jsonModel.relaxed === "undefined" ? true: this.jsonModel.relaxed;
            TextFormattingVisitor._super.initialize.call(this);
        },

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;
            for(var index = 0; index < chrCnt && (!this._relaxed || this._textPos < this.jsonModel._text.length); index++){
                switch (chr) {
                    case '9': // Numeric
                        var cUni = this.jsonModel._text.charAt(this._textPos++);
                        if(!xfalib.ut.PictureUtils.isDigit(cUni)){
                            throw "TextFormatting: not a digit as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'A': // Alphebetic
                        var cUni = this.jsonModel._text.charAt(this._textPos++);
                        if(!xfalib.ut.PictureUtils.isLetter(cUni)){
                            throw "TextFormatting: not a character as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'O': // Alphanumeric
                    case '0':
                        var cUni = this.jsonModel._text.charAt(this._textPos++);
                        // cUni === "" is a hack for LC-6152
                        // To prevent extra loop[one more time than the length of the string] for which cUni was ""
                        // which was neither a letter nor a digit
                        // so we were getting textformatting error
                        //which caused email id validation to fail for chars less than picture clause
                        if(!(cUni ==="" || xfalib.ut.PictureUtils.isLetter(cUni) || xfalib.ut.PictureUtils.isDigit(cUni))){
                            throw "TextFormatting: not a character or digit as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'X':
                        var cUni = this.jsonModel._text.charAt(this._textPos++);
                        this._buffer.push(cUni);
                        break;
                    case 't':
                        this._buffer.push("\t");
                        break;
                    default: this._buffer.push(chr);
                }
            }

        },

        /**
         *
         * @override
         */
        getResult : function(){
            if(this._textPos < this.jsonModel._text.length)
                throw "TextFormatting: picture clause smaller than input Text";
            return this._buffer.join("");
        },

        /**
         *
         * @override
         */
        acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "9AO0Xt");
        },

        consumeCharLiteral : function(token){
         this._buffer.push(""+ this.jsonModel._sPicture.charAt(token.startPos));
         // LC-3869 : forward the text pointer after literal is present and matched with the picture.
         if(this.jsonModel._sPicture.charAt(token.startPos) == this.jsonModel._text.charAt(token.startPos))
             this._textPos++;
        }
    })

})(_,xfalib);


/**
 * @package xfalib.ut.TextFormattingVisitor
 * @import xfalib.ut.FormattingVisitorBase
 * @fileOverview The file provides formating logic on date pattern characters.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param object {jsonModel: {_sPicture:String,_timeInfo: xfalib.ut.TimeInfo}}
 */

(function(_,xfalib){
    var TimeFormattingVisitor = xfalib.ut.TimeFormattingVisitor=  xfalib.ut.FormattingVisitorBase.extend({

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;

            switch (chr) {
                case 'H':
                case 'K':
                    var hourOfDay = this.jsonModel._timeInfo.mHourOfDay;
                    if(chr=='K'){
                        hourOfDay += 1;
                    }
                    switch(chrCnt){
                        case 1:
                            this._buffer.push(hourOfDay);
                            break;
                        case 2:
                            this._buffer.push(xfalib.ut.PictureUtils.padding(hourOfDay,2));
                            break;
                    }
                    break;

                case 'M':
                    var minuteOfHour = this.jsonModel._timeInfo.mMinuteOfHour;
                    switch(chrCnt){
                        case 1:
                            this._buffer.push(minuteOfHour);
                            break;
                        case 2:
                            this._buffer.push(xfalib.ut.PictureUtils.padding(minuteOfHour,2));
                            break;
                    }

                    break;
                case 'S':
                    var secondOfMinute = this.jsonModel._timeInfo.mSecondOfMinute;
                    switch(chrCnt){
                        case 1:
                            this._buffer.push(secondOfMinute);
                            break;
                        case 2:
                            this._buffer.push(xfalib.ut.PictureUtils.padding(secondOfMinute,2));
                            break;
                    }
                    break;
                case 'F':
                    var Milliseconds =this.jsonModel._timeInfo.mThousandthOfSecond;
                    this._buffer.push(xfalib.ut.PictureUtils.padding(Milliseconds,3));
                    break;

                default: throw "Unsupported pattern";
            };

        },

        /**
         *
         * @override
         */
        getResult : function(){
            return this._buffer.join("");
        }

    });

})(_,xfalib);


/**
 * @package xfalib.ut.NumFormattingVisitor
 * @import xfalib.ut.FormattingVisitorBase
 * @fileOverview Formats a string according to Text Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object { jsonModel:{_sPicture: String}, text: String}
 */

(function(_,xfalib){
    var PictureUtils =  xfalib.ut.PictureUtils;
    var NumFormattingVisitor = xfalib.ut.NumFormattingVisitor = xfalib.ut.FormattingVisitorBase.extend({

        initialize: function(options) {
            NumFormattingVisitor._super.initialize.call(this);
            this._textPos = 0;

            //boolean value used for internal state track
            this._mbDigitAddedToOutput = false; // at least one digit has been added to output
            this._mbSignAddedToOutput = false;
            this._nScannedPatternDigit = 0; //how many digit(98Zz) characters scanned in pattern, reset to 0 after '.Vv'
            this._mbRadixSeen = false;

            this._pictureDesc = new xfalib.ut.NumPictureDesc({jsonModel:{_sPicture:this.jsonModel._sPicture}});
            this.jsonModel._sPicture= this._pictureDesc.getPicture();
            this._numberInfo = this._pictureDesc.parseNumberInfo(options.text);

            this._mbNegative = this._numberInfo.isNegative;
            this._msText = this._numberInfo.msText;
            this._leadingPadding = this._numberInfo.padding;
            //
            this._mNumberSymbols = xfalib.ut.PictureUtils.getLocaleObject(this.jsonModel._locale,"numberSymbols");
            this._mCurrencySymbols = xfalib.ut.PictureUtils.getLocaleObject(this.jsonModel._locale,"currencySymbols");
        },

        _checkAndAddDecimalPoint: function(fw) {
            if(this._mAddRadix) {
                this._buffer.push(this._fmtStr(this._mNumberSymbols.decimal, fw));
                this._mAddRadix = false;
            }
        },

        consumeSubPattern : function(token){
            var chr = token.patChar,
                chrCnt = token.len;
            switch (chr) {
                case '9':
                case '8':
                case 'Z': // Digit or space if zero.
                case 'z':// Digit or nothing if zero.
                    if(!this._mbSignAddedToOutput)
                        this._ensureSignIsAdded();
                    while (chrCnt-- > 0 ) {
                        if(!this._mbRadixSeen){
                            if(this._leadingPadding > this._nScannedPatternDigit++){
                                var placeHolder = null;
                                if(this._mbDigitAddedToOutput){
                                    placeHolder = this._mNumberSymbols.zero;
                                }else{
                                    if(chr == '9' || chr =='8') {
                                        placeHolder = this._mNumberSymbols.zero;
                                        this._mbDigitAddedToOutput = true;
                                    }else if(chr == 'Z'){
                                        placeHolder = " ";
                                    }
                                }
                                if(placeHolder){
                                    this._buffer.push(this._matchChr(placeHolder));
                                }
                            }else {
                                var cValue = this._msText.charAt(this._textPos++);
                                this._ensureCharIsDigit(cValue);
                                this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,cValue));
                                this._mbDigitAddedToOutput = true;
                            }
                        }else{  //handling fractional part
                            if(this._nScannedPatternDigit++  < this._numberInfo.fractionDigit ){
                                var cValue = this._msText.charAt(this._textPos++);
                                this._ensureCharIsDigit(cValue);
                                this._checkAndAddDecimalPoint();
                                this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,cValue));
                                this._mbDigitAddedToOutput = true;
                            }else{
                                if(chr == '9'|| chr =='Z') {
                                    this._checkAndAddDecimalPoint();
                                    this._buffer.push(this._matchChr(this._mNumberSymbols.zero));
                                } else if(chr == '8') {
                                    var cValue = this._msText.charAt(this._textPos++);
                                    if(cValue != '' && this._ensureCharIsDigit(cValue)) {
                                        this._checkAndAddDecimalPoint();
                                        this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,cValue));
                                        this._mbDigitAddedToOutput = true;
                                    }
                                }
                            }
                        }

                    }

                    break;
                case 'E': // Exponent.
                    this._buffer.push('E');
                    this._buffer.push("" + this._numberInfo.shift);
                    break;
                case 'C': // CR symbol if negative and spaces if positive.
                    this._buffer.push((this._mbNegative) ? xfalib.ut.NumPictureDesc.gsCR : xfalib.ut.NumPictureDesc.gsDSP);
                    break;
                case 'c': // CR symbol if negative and nothing if positive.
                    if (this._mbNegative){
                        this._buffer.push(xfalib.ut.NumPictureDesc.gsCR);
                    }
                    break;
                case 'D': // DB symbol if negative and spaces if positive.
                    this._buffer.push((this._mbNegative) ? xfalib.ut.NumPictureDesc.gsDB : xfalib.ut.NumPictureDesc.gsDSP);
                    break;
                case 'd': // DB symbol if negative and nothing if positive.
                    if (this._mbNegative){
                        this._buffer.push(xfalib.ut.NumPictureDesc.gsDB);
                    }
                    break;
                case 'S': // Minus sign if negative and a space if positive.
                case 's':
                    if (this._mbNegative){
                        this._buffer.push(this._fmtStr(	this._mNumberSymbols.minus));
                    }else{
                        if('S' == chr){
                            this._buffer.push(this._matchChr(' '));
                        }
                    }
                    break;
                case 'V': // Implied decimal sign if parsing.
                case '.':
                case 'v': // Implied decimal sign.
                    if (this._textPos < this._msText.length && this._msText.charAt(this._textPos) == '.'){
                        this._textPos++; //consume a '.'
                    }
                    if (chr == 'V' || chr == '.'){
                        this._mAddRadix = true;
                        //this._buffer.push(this._fmtStr(this._mNumberSymbols.decimal, ));
                    }
                    this._mbRadixSeen = true;
                    this._nScannedPatternDigit = 0;
                    break;

                case 0xFF0C: // Fullwidth ','.
                case ',': // Grouping separator.
                    while (chrCnt-- > 0) {
                        if (this._mbDigitAddedToOutput){
                            this._buffer.push(this._fmtStr(	this._mNumberSymbols.grouping ));
                        }
                        this._mbCommaSeen = true;
                    }
                    break;
                case 0xFF04: // Fullwidth '$'.
                case '$': // Currency name or symbol.
                    while (chrCnt-- > 0) {
                        this._buffer.push(this._fmtStr(	this._mCurrencySymbols.symbol ));
                    }
                    break;
                case 0xFF05: // Fullwidth '%'.
                case '%': // Percent symbol.
                    while (chrCnt-- > 0) {
                        this._buffer.push(this._fmtStr(	this._mNumberSymbols.percent));
                    }
                    break;
                case 0xFF08: // Fullwidth '('.
                case 0xFF09: // Fullwidth ')'.
                case '(': // Left parenthesis.
                case ')': // Right parenthesis.
                    this._buffer.push(this._matchChr((this._mbNegative) ? chr : ' '));
                    break;
                default:
            }
        },

        _ensureCharIsDigit : function(cValue){
            if ('0' > cValue || cValue > '9'){
                throw "Nuberic Formatting: not a digit as expected " + cValue;
            }
        },


        _fmtStr : function(str){
            return str;
        },

        _matchStr : function(str){
            return str;
        },

        _matchChr : function(str){
            return str;
        },

        _ensureSignIsAdded : function(){
            if (this._mbNegative && ! this._mbDigitAddedToOutput && ! this._pictureDesc.hasSign) {
                this._buffer.push(this._mNumberSymbols.minus);
                this._mbSignAddedToOutput = true;
            }
        },

        /**
         *
         * @override
         */
        getResult : function(){
            return this._buffer.join("");
        },

        /**
         *
         * @override
         */
        acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "(%$,.)89BCDERSVZbcdrsvzt");
        }

    });

})(_,xfalib);


/**
 * @package xfalib.ut.TimeParsingVisitor
 * @import xfalib.ut.ParsingVisitorBase
 * @fileOverview The file provides parsing/formating logic on date pattern characters.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String, _dataString: String]}
 */

(function(_,xfalib){
    var TimeParsingVisitor = xfalib.ut.TimeParsingVisitor = xfalib.ut.ParsingVisitorBase.extend({

        initialize: function() {
            this._timeInfo = new xfalib.ut.TimeInfo();
            TimeParsingVisitor._super.initialize.call(this);
        },

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;
            var curPos = this._strPos;
            var scannedChar = chrCnt;
            this._assert(curPos+chrCnt <=this.jsonModel._dataString.length, "Mismatch");

            switch (chr) {
                case 'h':
                    if(this._timeInfo.mHourOfMeriDiem != -1 || this._timeInfo.mHourOfDay != -1){
                        throw "ambiguity time string";
                    }
                    var hourOfMeriDiem=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-12)
                            hourOfMeriDiem = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            hourOfMeriDiem = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-12)
                            break;
                    }

                    this._timeInfo.mHourOfMeriDiem = hourOfMeriDiem -1;
                    this._assert(this._timeInfo.mHourOfMeriDiem>=0 && this._timeInfo.mHourOfMeriDiem<=11, "Invalid Hour Of MeriDiem value.");
                    break;

                case 'k':
                    if(this._timeInfo.mHourOfMeriDiem != -1 || this._timeInfo.mHourOfDay != -1){
                        throw "ambiguity time string";
                    }
                    var hourOfMeriDiem=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-11)
                            hourOfMeriDiem = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            hourOfMeriDiem = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-11)
                            break;
                    }

                    this._timeInfo.mHourOfMeriDiem = hourOfMeriDiem;
                    this._assert(this._timeInfo.mHourOfMeriDiem>=0 && this._timeInfo.mHourOfMeriDiem<=11, "Invalid hour of meriDiem value.");
                    break;

                case 'H':
                    if(this._timeInfo.mHourOfMeriDiem != -1 || this._timeInfo.mHourOfDay != -1){
                        throw "ambiguity time string";
                    }
                    var hourOfDay=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-23)
                            hourOfDay = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            hourOfDay = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-23)
                            break;
                    }

                    this._timeInfo.mHourOfDay = hourOfDay;
                    this._assert(this._timeInfo.mHourOfDay>=0 && this._timeInfo.mHourOfDay<=23, "Invalid hour of day value.");
                    break;

                case 'K':
                    if(this._timeInfo.mHourOfMeriDiem != -1 || this._timeInfo.mHourOfDay != -1){
                        throw "ambiguity time string";
                    }
                    var hourOfDay=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-23)
                            hourOfDay = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            hourOfDay = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-23)
                            break;
                    }

                    this._timeInfo.mHourOfDay = hourOfDay - 1;
                    this._assert(this._timeInfo.mHourOfDay>=0 && this._timeInfo.mHourOfDay<=23, "Invalid hour of day value.");
                    break;
                case 'M':
                    if(this._timeInfo.mMinuteOfHour != -1){
                        throw "ambiguity time string";
                    }
                    var minuteOfHour=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-59)
                            minuteOfHour = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            minuteOfHour = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-59)
                            break;
                    }

                    this._timeInfo.mMinuteOfHour = minuteOfHour;
                    this._assert(this._timeInfo.mMinuteOfHour>=0 && this._timeInfo.mMinuteOfHour<=59, "Invalid minute of hour.");
                    break;
                case 'S':
                    if(this._timeInfo.mSecondOfMinute != -1){
                        throw "ambiguity time string";
                    }
                    var secondOfMinute=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-59)
                            secondOfMinute = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            secondOfMinute = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-59)
                            break;
                    }

                    this._timeInfo.mSecondOfMinute = secondOfMinute;
                    this._assert(this._timeInfo.mSecondOfMinute>=0 && this._timeInfo.mSecondOfMinute<=59, "Invalid second of minute.");
                    break;
                case 'F':

                    this._assert(chrCnt==3, "Invalid pattern F.");
                    this._timeInfo.mThousandthOfSecond = this.parseIntExact(this.jsonModel._dataString, curPos, 3);
                    this._assert(this._timeInfo.mThousandthOfSecond>=0 && this._timeInfo.mThousandthOfSecond<=999, "Invalid thousand of second.");
                    break;

                default: throw "Unsupported pattern";
            }

            this._strPos += scannedChar;
        },

        parseIntAggressive : xfalib.ut.PictureUtils.parseIntAggressive,

        parseIntExact : xfalib.ut.PictureUtils.parseIntExact,

        getResult : function(){
            return this._timeInfo.getISOTime();
        },

        getTimeInfo : function(){
            return this._timeInfo;
        },

        _assert : function(condition, message){
            if(!condition){
                throw message;
            }
        }
    });
})(_,xfalib);



/**
 * @package xfalib.ut.TextParsingVisitor
 * @import xfalib.ut.ParsingVisitorBase
 *
 * @fileOverview Parses a string according to Text Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String, _dataString: String]}
 */
(function(_,xfalib){
    var TextParsingVisitor = xfalib.ut.TextParsingVisitor = xfalib.ut.ParsingVisitorBase.extend({

        initialize: function() {
            TextParsingVisitor._super.initialize.call(this);
            this._buffer = [];
        },

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;
            for(var index = 0; index < chrCnt; index++){
                switch (chr) {
                    case '9': // Numeric
                        var cUni = this.jsonModel._dataString.charAt(this._strPos++);
                        if(!xfalib.ut.PictureUtils.isDigit(cUni)){
                            throw "TextParsing: not a digit as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'A': // Alphebetic
                        var cUni = this.jsonModel._dataString.charAt(this._strPos++);
                        if(!xfalib.ut.PictureUtils.isLetter(cUni)){
                            throw "TextParsing: not a character as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'O': // Alphanumeric
                    case '0':
                        var cUni = this.jsonModel._dataString.charAt(this._strPos++);
                        if(!xfalib.ut.PictureUtils.isLetterOrDigit(cUni)){
                            throw "TextParsing: not a character or digit as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'X':
                        var cUni = this.jsonModel._dataString.charAt(this._strPos++);
                        this._buffer.push(cUni);
                        break;
                    case 't':
                        if(this.jsonModel._dataString.charAt(this._strPos++)=="\t"){
                            this._buffer.push("\t");
                        }else{
                            throw "TextParsing: not a Tab as expected";
                        }
                        break;
                    default:
                        if(this.jsonModel._dataString.charAt(this._strPos++)== chr){
                            this._buffer.push(chr);
                        }else{
                            throw "TextParsing: not '" + chr+"' as expected";
                        }
                }
            }

        },
        /**
         *
         * @override
         */
        getResult : function(){
            if(this._strPos < this.jsonModel._dataString.length)
                throw "TextParsing: picture clause smaller than input Text";
            return this._buffer.join("");
        },
        /**
         *
         * @override
         */
        acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "9AO0Xt");
        }

    });
})(_,xfalib);


/**
 * @package xfalib.ut.NumParsingVisitor
 * @import xfalib.ut.ParsingVisitorBase
 * @fileOverview Parses a string according to Text Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String,_dataString: String}}
 */

(function(_,xfalib){
    var NumParsingVisitor = xfalib.ut.NumParsingVisitor = xfalib.ut.ParsingVisitorBase.extend({

        initialize: function(options) {
            this._pictureDesc = new xfalib.ut.NumPictureDesc({jsonModel:{_sPicture:this.jsonModel._sPicture}});
            this.jsonModel._sPicture = this._pictureDesc.getPicture();
            this._buffer = [];
            this._strPos = 0;
            this._hasRadix = false;
            this._mbNegative = false;
            this._mbDigitSeen = false; // at least one digit has been added to output
            this._mbSignSeen = false;
            this._mBacktrack = null;
            this._hasPercent = false;
            this._mbExponSeen = false;

            this._mNumberSymbols = xfalib.ut.PictureUtils.getLocaleObject(this.options._locale,"numberSymbols");
            this._mCurrencySymbols = xfalib.ut.PictureUtils.getLocaleObject(this.options._locale,"currencySymbols");
        },

        _lookupNext : xfalib.ut.Scanner.lookupNext,

        parse : function(){
            var patPos = 0;
            while(true){
                try{
                    for(var token = this._lookupNext(this.jsonModel._sPicture, patPos, this.acceptPatternChar); token != null;  ){
                        this.consume(token);
                        patPos = patPos + token.len;
                        token = this._lookupNext(this.jsonModel._sPicture, patPos, this.acceptPatternChar);
                    }
                }catch(e){
                    //mismatch, try again!
                    if(this._mBacktrack){
                        patPos = this._mBacktrack.patPos;
                        this._buffer.length = 0;
                        this._strPos = this._mBacktrack.strPos;
                        this._mbDigitSeen = false;
                        this._mBacktrack = null;
                        continue;
                    }
                }
                break;
            }
        },
        consumeSubPattern : function(token){

            var chr = token.patChar;
            var chrCnt = token.len;
            var fw = false;
            switch (chr) {
                case '9':
                case '8':
                case 'Z': // Digit or space if zero.
                case 'z':// Digit or nothing if zero.
                    while (chrCnt-- > 0 ) {
                        if(!this._mbDigitSeen){
                            var cUni = this.jsonModel._dataString.charAt(this._strPos);
                            if(cUni == '-'){
                                this._mbNegative = true;
                                cUni = this.jsonModel._dataString.charAt(++this._strPos);
                            }
                            if(chr== '9' || chr == '8'){
                                if(!xfalib.ut.PictureUtils.isDigit(cUni)){
                                    throw "TextParsing: not a digit as expected";
                                }
                                this._buffer.push(cUni);
                                this._mbDigitSeen =true;
                            }else if(chr =='Z'){
                                if(xfalib.ut.PictureUtils.isDigit(cUni)){
                                    this._buffer.push(cUni);
                                    this._mbDigitSeen =true;
                                }else if(cUni != ' '){
                                    throw "TextParsing: not a digit or space as expected";
                                }
                            }else {
                                // has to be 'z', eagerly try to match a digit, if a mismatch is latterly found, backtrack
                                if(xfalib.ut.PictureUtils.isDigit(cUni)){
                                    this._buffer.push(cUni);
                                    this._mbDigitSeen =true;
                                    this._mBacktrack = {
                                        "patPos" : token.patPos + token.len - chrCnt, //new position from next char after 'z'
                                        "strPos" : this._strPos
                                    };
                                }else {
                                    throw "TextParsing: not a digit or space as expected";
                                }
                            }
                            ++this._strPos;
                        }else{
                            var cUni = this.jsonModel._dataString.charAt(this._strPos);
                            if(xfalib.ut.PictureUtils.isDigit(cUni)){
                                this._buffer.push(cUni);
                                ++this._strPos;
                            }else{
                                if(chr !='z'){
                                    throw "TextParsing: not a digit as expected";
                                }else{
                                    ++this._strPos;
                                }
                            }
                        }
                    }

                    break;
                case 'V' :
                case 'v' :
                case '.' :
                    if(this._matchStr(this._mNumberSymbols.decimal)){
                        this._hasRadix = true;
                        this._buffer.push('.');
                        this._mbDigitSeen =true;
                    }else{
                        throw "TextParsing: not a radix as expected";
                    }
                    break;
                case 'E': // Exponent.
                    if(this._matchStr('E')){
                        this._buffer.push('E');
                        if(this._matchStr('+')){
                            //
                        }else if(this._matchStr('-')){
                            this.jsonModel._buffer.push('-');
                        }
                        var strLen = this.jsonModel._dataString.length;
                        while(this._strPos < strLen &&
                            xfalib.ut.PictureUtils.isDigit(this.jsonModel._dataString.charAt(this._strPos))){
                            this._buffer.push(this.jsonModel._dataString.charAt(this._strPos++));
                        }
                    }
                    break;

                case 'C': // CR symbol if negative and spaces if positive.
                    if(this._matchStr(xfalib.ut.NumPictureDesc.gsCR)){
                        this._mbNegative = true;
                    }else if(!this._matchStr(xfalib.ut.NumPictureDesc.gsDSP)){
                        throw "TextParsing: not a CR as expected";
                    }
                    break;
                case 'c': // CR symbol if negative and nothing if positive.
                    if(this._matchStr(xfalib.ut.NumPictureDesc.gsCR)){
                        this._mbNegative = true;
                    }
                    break;
                case 'D': // DB symbol if negative and spaces if positive.
                    if(this._matchStr(xfalib.ut.NumPictureDesc.gsDB)){
                        this._mbNegative = true;
                    }else if(!this._matchStr(xfalib.ut.NumPictureDesc.gsDSP)){
                        throw "TextParsing: not a CR as expected";
                    }
                    break;
                case 'd': // DB symbol if negative and nothing if positive.
                    if(this._matchStr(xfalib.ut.NumPictureDesc.gsDB)){
                        this._mbNegative = true;
                    }
                    break;
                case 'S': // Minus sign if negative and a space if positive.
                    if(this._matchStr(this._mNumberSymbols.negative,fw)){
                        this._mbNegative = true;
                    }else if(!this._matchStr(" ")){
                        throw "TextParsing: not a CR as expected";
                    }
                    break;
                case 's':
                    if(this._matchStr(this._mNumberSymbols.negative,fw)){
                        this._mbNegative = true;
                    }
                    break;
                case 0xFF0C: // Fullwidth ','.
                case ',': // Grouping separator.
                    while (chrCnt-- > 0) {
                        if(!this._matchStr(this._mNumberSymbols.grouping, fw)){
                            throw "TextParsing: not a grouping symbol as expected";
                        }
                    }
                    break;
                case 0xFF04: // Fullwidth '$'.
                case '$': // Currency name or symbol.
                    while (chrCnt-- > 0) {
                        if(!this._matchStr(this._mCurrencySymbols.symbol, fw)){
                            throw "TextParsing: not a grouping symbol as expected";
                        }
                    }
                    break;
                case 0xFF05: // Fullwidth '%'.
                case '%': // Percent symbol.
                    while (chrCnt-- > 0) {
                        if(!this._matchStr(this._mNumberSymbols.percent, fw)){
                            throw "TextParsing: not a grouping symbol as expected";
                        }
                    }
                    this._hasPercent = true;
                    break;
                case 0xFF08: // Fullwidth '('.
                case 0xFF09: // Fullwidth ')'.
                case '(': // Left parenthesis.
                case ')': // Right parenthesis.
                    if(this._matchStr(chr,fw)){
                        this._mbNegative = true;
                    }else if(!this._matchStr(" ")){
                        throw "TextParsing: not parentesis as expected";
                    }
                    break;
                case 't': // tab.
                    while (chrCnt-- > 0) this._matchStr('\t',fw);
            }
        },
        getResult : function(){
            var stringNum =  this._buffer.join("");
            if(this._hasPercent) {
                var buf = new Array();
                stringNum = Number(stringNum).toString();
                var dot = stringNum.indexOf('.');

                var pos = dot-2;
                if(pos ==0) buf.push("0");
                else if(pos ==-1) buf.push("0.0");
                else if(pos ==-3) pos = stringNum.length - 2;
                for(var index=0;index < stringNum.length; index++){
                    if(index == pos){
                        buf.push(".");
                    }
                    if(index != dot){
                        buf.push(stringNum.charAt(index));
                    }
                }
                stringNum = buf.join("");
            }
            var number = Number(stringNum);
            if(this._mbNegative) number = -number;
            return number.toString();
        },

        _matchStr : function(target){
            if(xfalib.ut.PictureUtils.matchString(this.jsonModel._dataString, this._strPos, target)){
                this._strPos+= target.length;
                return true;
            }else{
                return false;
            }
        },

        /**
         *
         * @override
         */
        acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "(%$,.)89BCDERSVZbcdrsvzt");
        }
    });
})(_,xfalib);
/**
 * @package xfalib.ut.DateParsingVisitor
 * @import xfalib.ut.ParsingVisitorBase
 * @fileOverview The file provides parsing/formating logic on date pattern characters.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String, _dataString: String]}
 */

(function(_,xfalib) {
    var DateParsingVisitor = xfalib.ut.DateParsingVisitor = xfalib.ut.ParsingVisitorBase.extend({

        initialize: function() {
            this._dateInfo = new xfalib.ut.DateInfo({isParsingCall : true});
            this._dayOfMonth = this._monthOfYear = this._yearOfEra = null; // used to validate date once all sub patterns are consumed
            DateParsingVisitor._super.initialize.call(this);
        },

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;
            var curPos = this._strPos;
            var scannedChar = chrCnt;

            //TODO: need to remove this assert.
            this._assert(curPos+chrCnt <=this.jsonModel._dataString.length, "Mismatch");

            switch (chr) {
                case 'D':
                    switch(chrCnt){
                        case 1:
                            var parsed = xfalib.ut.PictureUtils.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-31)
                            this._dayOfMonth = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            this._dayOfMonth = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-31)
                            break;
                    }
                    this._assert(this._dayOfMonth <= 31 && this._dayOfMonth >0, "Invalid date string1");
                    break;
                case 'J':

                    //this._mDayOfYear;
                    break;
                case 'M':
                    var symbol = "";
                    switch(chrCnt){
                        case 1:
                            var parsed = xfalib.ut.PictureUtils.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-12)
                            this._monthOfYear = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            this._monthOfYear = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._dataString, curPos, 2); // 2 digit(01-12)
                            break;
                        case 3:
                            symbol = "calendarSymbols.abbrmonthNames";
                            break;
                        case 4:
                            symbol = "calendarSymbols.monthNames"
                            break;

                    }
                    if(symbol) {
                        var hashObj = xfalib.ut.PictureUtils.getHashOfLocaleObject(this.jsonModel._locale,symbol),
                            str = this.jsonModel._dataString.toLowerCase(),
                            hash = 0,
                            curStr = ""
                        scannedChar = 0;
                        while(curPos+scannedChar < str.length) {
                            hash += (scannedChar+1)*str.charCodeAt(curPos+scannedChar)
                            curStr+= str.charAt(curPos+scannedChar);
                            scannedChar++;
                            if(hashObj[hash] && hashObj[hash].indexOf(curStr) > -1 ) break;
                        }
                        var monthNames = _.map(xfalib.ut.PictureUtils.getLocaleObject(this.jsonModel._locale, symbol), function (str) {
                            return str.toLowerCase();
                        });
                        this._monthOfYear = monthNames.indexOf(curStr) + 1; // months are from 1 to 12
                    }
                    //TODO: remove this assert
                    this._assert(this._monthOfYear <= 12 && this._monthOfYear >0, "Invalid date string2");
                    break;
                case 'E':
                    var symbol = ""
                    switch(chrCnt) {
                        case 1:
                            scannedChar = 1;
                            break;
                        case 3:
                            symbol = "calendarSymbols.abbrdayNames";
                            break;
                        case 4:
                            symbol = "calendarSymbols.dayNames"
                            break;
                        default:
                            throw "unsupported Picture Clause ";
                    }
                    if(symbol) {
                        var hashObj = xfalib.ut.PictureUtils.getHashOfLocaleObject(this.jsonModel._locale,symbol);
                        scannedChar = 0;
                        var str = this.jsonModel._dataString.toLowerCase();
                        var hash = 0;
                        var curStr = "";
                        while(curPos+scannedChar < str.length) {
                            hash += (scannedChar+1)*str.charCodeAt(curPos+scannedChar)
                            curStr+= str.charAt(curPos+scannedChar);
                            scannedChar++;
                            if(hashObj[hash] && hashObj[hash].indexOf(curStr) > -1) break;
                        }
                    }
                    break;

                case 'e':
                    break;
                case 'G':
                    break;
                case 'Y':

                    switch(chrCnt){
                        case 2:
                            this._yearOfEra = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._dataString, curPos, 2); // 2 digit(00-99)
                            this._yearOfEra+=2000;
                            if(this._yearOfEra >= 2029){
                                this._yearOfEra -=100;
                            }
                            break;
                        case 4:
                            this._yearOfEra = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._dataString, curPos, 4); // 2 digit(0000-9999)
                            break;
                    }

                    this._assert(this._yearOfEra <= 9999 && this._yearOfEra >=0, "Invalid date string3");
                    break;
                case 'w':
                    break;
                case 'W':
                    break;
                default: throw "Unsupported pattern";
            }

            if(this._yearOfEra && this._monthOfYear && this._dayOfMonth){
                this._dateInfo.validate(this._yearOfEra, this._monthOfYear, this._dayOfMonth);
            }

            this._strPos += scannedChar;
        },

        getDate : function(){
            return this._dateInfo.date;
        },

        getResult: function(){
            if (this._strPos < this.jsonModel._dataString.length) {
                throw "DateParsing: picture clause smaller than input Date";
            }
            return this._dateInfo.getISODate();
        },

        _assert : function(condition, message){
            if(!condition){
                throw message;
            }
        }
    });
})(_,xfalib);

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/



(function(_, $, xfalib){

    var LocalizationUtil = xfalib.ut.LocalizationUtil = xfalib.ut.Class.extend({

        getLocalizedMessage: function(category, message, snippets){
            var resolvedMessage = message;
            if(snippets){
                //resolve message with snippet
                resolvedMessage = resolvedMessage.replace(/{(\d+)}/g, function(match, number) {
                    return typeof snippets[number] != 'undefined'
                        ? snippets[number]
                        : match
                        ;
                });
            }
            var text = "";
            if (category) {
                text += " [" + category + "]";
            }
            text += "  " + resolvedMessage + "\r\n" ;
            return text;
        }

    });
})(_, $, xfalib);


/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/




(function(_, $, xfalib){
    xfalib.view.util.TextMetrics = {
        xfaUtil : xfalib.ut.XfaUtil.prototype,
        ERROR_MARGIN : 1,
        $measureEl : null,
        initialize : function(divEl){
            if(!divEl){
                var $div = $("<div></div>");
                $div.attr("id", "textMetrics");
                var divStyles = {};
                divStyles.left = -1000;
                divStyles.top = -1000;
                divStyles.position = "absolute";
                divStyles.visibility = "hidden";
                this.xfaUtil.$css($div.get(0), divStyles);
                this.$measureEl = $div;
                $("body").append(this.$measureEl);
            }else{
                this.$measureEl = divEl;
            }
        },

        measureExtent : function(text, options){
            text = text + " ";
            if(!this.$measureEl){
                this.initialize();
            }
            options = options || {};
            var textStyles = {};
            var $refEl =  $(options.refEl || "<div></div>") ;
            var refEl = $refEl.get(0);
            textStyles.fontSize = $refEl.css("fontSize") || options["font-size"] || options["fontSize"];
            textStyles.fontStyle = $refEl.css("fontStyle") || options["font-style"] || options["fontStyle"];
            textStyles.fontWeight = $refEl.css("fontWeight") || options["font-weight"] || options["fontWeight"];
            textStyles.fontFamily = $refEl.css("fontFamily") || options["font-family"] || options["fontFamily"];
            textStyles.lineHeight = refEl.style.lineHeight || options["line-height"] || options["lineHeight"];
            textStyles.letterSpacing = $refEl.css("letterSpacing") || options["letter-spacing"] || options["letterSpacing"];
            textStyles.whiteSpace =  $refEl.css("whiteSpace") || options["white-space"] || options["whiteSpace"] || "pre-wrap";
            if( $.browser.mozilla && $refEl.is("textarea"))      // for Bug #3621180
                textStyles.whiteSpace = "pre-wrap";
            textStyles.wordBreak =  $refEl.css("wordBreak") || options["word-break"] || options["wordBreak"] || "break-all";
            textStyles.wordWrap =  $refEl.css("wordWrap") || options["word-wrap"] || options["wordWrap"] || "break-word";
            textStyles.width = this._elWidth(refEl, options);
            textStyles.height = this._elHeight(refEl, options);
            textStyles.minWidth = this._elMinWidth(refEl, options);
            textStyles.minHeight = this._elMinHeight(refEl, options);
            textStyles.maxWidth = this._elMaxWidth(refEl, options);
            textStyles.maxHeight = this._elMaxHeight(refEl, options);
            this.xfaUtil.$css(this.$measureEl.get(0), textStyles);
            // for text fields/areas and draw requiring rich text support
            if(options.contentType === "text/html"){
              // retaining for future use . If we use the above property for other rich text
               if(options.skipXSSProtection) {
                 this.$measureEl.html(text);
               } else {
                 this.$measureEl.html(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(text));
               }
            }else {
               text = text.replace(/\n\r/g,"\n").replace(/\r\n/g,"\n").replace(/\r/g, "\n");
               this.$measureEl.text(text);
            }
            var measuredWidth =  this.$measureEl.width();
            var measuredHeight =  this.$measureEl.height();

            if(measuredWidth == Math.ceil(options["width"]) || measuredWidth == Math.floor(options["width"])){
                measuredWidth = options["width"];
            }
            /*
             FORMS-11363 : fix for height calculation of table cell
             Enable this toggle for old behaviour (if any regression comes)
             */
            else if ((window.FD && window.FD.isToggleEnabled("FT_FORMS-11363")) && (options["maxWidth"] > measuredWidth || (measuredWidth > options["minWidth"] > 0 && (options["maxWidth"] || -1) < 0))) {
                //complicated, please simplify if below hurts you:  Add error margin if there is scope of further extension of extent
                measuredWidth = measuredWidth + 1;
            } else if (options["maxWidth"] > measuredWidth || (measuredWidth > options["minWidth"] > 0 && (options["maxWidth"] || -1) < 0)) {
                //complicated, please simplify if below hurts you:  Add error margin if there is scope of further extension of extent
                measuredWidth = measuredWidth;
            }

            if(measuredHeight == Math.ceil(options["height"]) || measuredHeight == Math.floor(options["height"])){
                measuredHeight = options["height"];
            }
            else if( $refEl.is("textarea") && (options["maxHeight"] > measuredHeight || (measuredHeight > options["minHeight"] > 0 && (options["maxHeight"] || -1) < 0))){
                measuredHeight = measuredHeight +1;
            }
            this.$measureEl.empty();
            return {width : measuredWidth, height : measuredHeight};
        },

        _elWidth : function(refEl, options){
            if(options["minWidth"] && options["minWidth"] > -1)
                return "auto";
            else if(options["maxWidth"] && options["maxWidth"] > -1)
                return "auto";
            else
                return options["width"] || "auto";
        },

        _elHeight : function(refEl, options){
            // TODO: check for calculations here for floating field and other cases.
            if(options["contentType"] === "text/html")
                return "auto";
            if(options.isDraw) { // for handling the case of draw having floating fields
                return "auto";
            }
            if(!$(refEl).is("textarea"))
                return options["height"] || "auto";
            if(options["minHeight"] && options["minHeight"] > -1)
                return "auto";
            else if(options["maxHeight"] && options["maxHeight"] > -1)
                return "auto";
            else
                return options["height"] || "auto";
        },

        _elMinWidth : function(refEl, options){
            if(options["minWidth"] && options["minWidth"] > -1)
                return options["minWidth"];
            else
                return "0"; //default css value
        },

        _elMinHeight : function(refEl, options){
            if(options["minHeight"] && options["minHeight"] > -1)
                return options["minHeight"];
            else
                return "0"; //default css value
        },

        _elMaxWidth : function(refEl, options){
            if(options["maxWidth"] && options["maxWidth"] > -1)
                return options["maxWidth"];
            else
                return "none"; //default css value
        },

        _elMaxHeight : function(refEl, options){
            if(options["maxHeight"] && options["maxHeight"] > -1)
                return options["maxHeight"];
            else
                return "none"; //default css value
        },

        _destroy : function() {
            $("#textMetrics").remove();
            this.$measureEl = null;
        }
    }
})(_, $, xfalib);
(function($, _) {

	$.alertBox = {

		verticalOffset: -75,
		horizontalOffset: 0,
		repositionOnResize: true,
		overlayOpacity: 0.01,
		overlayColor: '#FFF',
		draggable: false,
		dialogClass: null,
		imageDirectory: "..",
		images: ["A_Warning_Lg_N.png", "A_Alert2_Lg_N.png", "C_QuestionBubble_Xl_N.png", "A_InfoBlue_32x32_N.png"],

		alert: function(img, message, title, callback) {
			this._show(img, title, message, null, 'OK', function(result) {
				if( callback ) callback(result);
			});
		},

		okCancel: function(img, message, title, callback) {
			this._show(img, title, message, null, 'OK-Cancel', function(result) {
				if( callback ) callback(result);
			});
		},
		yesNo: function(img, message, title, callback) {
			this._show(img, title, message, null, 'Yes-No', function(result) {
				if( callback ) callback(result);
			});
		},

		yesNoCancel: function(img, message, title, callback) {
			this._show(img, title, message, null, 'Yes-No-Cancel', function(result) {
				if( callback ) callback(result);
			});
		},

		_createBox: function(msgBox_message,buttons,callback) {
			var that = this;
			$("#"+msgBox_message).after("<div id='msgBox_panel'>");
			_.each(buttons.split("-"),function(val,i) {
                var dispval = xfalib.locale.Strings[val.toLowerCase()] ? xfalib.locale.Strings[val.toLowerCase()] : val;  // keys in loaclization files are in lower-case
                $("#msgBox_panel").append("<input type='button' value='"+dispval+"' id = 'msgBox_"+val+"' class=msgbox_input />");
				$("#msgBox_"+val).click( function() {
					that._hide();
					callback(!i);
				});
				if(!i) $("msgBox_"+val).focus();
			});
		},

		_show: function(img, title, msg, value, type, callback) {

			this._hide();
			this._overlay('show');

			$("BODY").append(
			  '<div id="msgBox_container">' +
			    '<h1 id="msgBox_title"></h1>' +
			    '<div id="msgBox_content">' +
			      '<div id="msgBox_message"></div>' +
				'</div>' +
			  '</div>');

			if( this.dialogClass ) $("#msgBox_container").addClass($.alertBox.dialogClass);

			$("#msgBox_container").css({
				position: 'absolute',
				zIndex: 99999,
				padding: 0,
				margin: 0
			});

			$("#msgBox_title").text(title);
			$("#msgBox_content").addClass("msgBoxType"+img);//css("background-image","url("+this.imageDirectory+ this.images[img]+")");
			msg = xfalib.ut.XfaUtil.prototype.encodeScriptableTags(msg.replace(/\n/g, '<br />'));
            $("#msgBox_message").html(msg);

			$("#msgBox_container").css({
				minWidth: $("#msgBox_container").outerWidth(),
				maxWidth: $("#msgBox_container").outerWidth()
			});

			this._reposition();
			this._maintainPosition(true);

			this._createBox("msgBox_message",type,callback);

			//TODO: Make keyboard input work
			/*$("#msgBox_ok").keypress( function(e) {
				if( e.keyCode == 13 || e.keyCode == 27 ) $("#msgBox_ok").trigger('click');
			});
			$("#msgBox_cancel").keypress( function(e) {
				if( e.keyCode == 13 ) $("#msgBox_ok").trigger('click');
				if( e.keyCode == 27 ) $("#msgBox_cancel").trigger('click');
			});
			$("#msgBox_yes, #msgBox_no").keypress( function(e) {
				if( e.keyCode == 13 ) $("#msgBox_yes").trigger('click');
					if( e.keyCode == 27 ) $("#msgBox_no").trigger('click');
				});*/

		},

		_hide: function() {
			$("#msgBox_container").remove();
			this._overlay('hide');
			this._maintainPosition(false);
		},

		_overlay: function(status) {
			switch( status ) {
				case 'show':
					this._overlay('hide');
					$("BODY").append('<div id="msgBox_overlay"></div>');
					$("#msgBox_overlay").css({
						position: 'absolute',
						zIndex: 99998,
						top: '0px',
						left: '0px',
						width: '100%',
						height: $(document).height(),
						background: this.overlayColor,
						opacity: this.overlayOpacity
					});
				break;
				case 'hide':
					$("#msgBox_overlay").remove();
				break;
			}
		},

		_reposition: function() {
            var windowHeight = $(window).height() / xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowWidth = $(window).width() / xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowScrollTop =  $(window).scrollTop() / xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowScrollLeft =  $(window).scrollLeft() / xfalib.ut.XfaUtil.prototype.formScaleFactor,
			    top = ((windowHeight / 2) - ($("#msgBox_container").outerHeight() / 2)) + this.verticalOffset,
			    left = ((windowWidth / 2) - ($("#msgBox_container").outerWidth() / 2)) + this.horizontalOffset;
			if( top < 0 ) top = 0;
			if( left < 0 ) left = 0;

			// IE6 fix
			if( $.browser.msie && parseInt($.browser.version) <= 6 ) top = top + windowScrollTop;

			$("#msgBox_container").css({
				top: top + windowScrollTop + 'px',
				left:  left + windowScrollLeft + 'px'
			});
			$("#msgBox_overlay").height( $(document).height() );
		},

		_maintainPosition: function(status) {
			if( this.repositionOnResize ) {
				switch(status) {
					case true:
						$(window).on('resize', this._reposition);
					break;
					case false:
						$(window).off('resize', this._reposition);
					break;
				}
			}
		}

	};
})($, window._);/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2016 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/


(function(_, $, xfalib){
    xfalib.view.util.HtmlUtil = {
        /*
        * Most of the time it returns undefined while accessing an undefined attribute of a dom element.
        * But some browsers can throw specific exceptions while accessing an attribute which is un-supported for a specific case.
        * This API is to make this behaviour consistent across browsers and return undefined for un-supported attributes.
        * */
        getHTMLSupportedAttr : function($domElement, attr){
           try{
               return $domElement[attr];
            }
           catch (err){
               return undefined;
            }
        },

        /**
         * Checks if the attribute is supported for the given HTML element.
         * This is primarily useful to support HTML5 features in widgets
         * @param element       name of HTML element
         * @param attribute     attribute to check on the element
         * @returns {boolean}
         */
        elementSupportsAttribute : function (element, attribute) {
            var test = document.createElement(element);
            if (attribute in test) {
                $(test).remove();
                test = null;
                return true;
            } else {
                $(test).remove();
                test = null;
                return false;
            }
        }
    }
})(_, $, xfalib);
/*************************************************************************
*
* ADOBE CONFIDENTIAL
* ___________________
*
*  Copyright 2013 Adobe Systems Incorporated
*  All Rights Reserved.
*
* NOTICE:  All information contained herein is, and remains
* the property of Adobe Systems Incorporated and its suppliers,
* if any.  The intellectual and technical concepts contained
* herein are proprietary to Adobe Systems Incorporated and its
* suppliers and are protected by trade secret or copyright law.
* Dissemination of this information or reproduction of this material
* is strictly forbidden unless prior written permission is obtained
* from Adobe Systems Incorporated.
**************************************************************************/



(function(_, $, xfalib){
    xfalib.view.util.Styles = {
        xfaUtil : xfalib.ut.XfaUtil.prototype,
        _deviceResolution :  144.0, //DPI
        _in2mmFactor : 25.4,
        _pdfResolution : 72.0 ,
        getStyleForEdge : function (edgeElement, str, cssStyleObj){
            var style = { "raised" : "outset" ,
                "dashDot" : "dashed" ,
                "dashDotDot" : "dashed" ,
                "dashed" : "dashed" ,
                "dotted" : "dotted" ,
                "embossed" : "groove" ,
                "etched" : "inset" ,
                "lowered" : "ridge",
                "solid" : "solid"};
            if(edgeElement && edgeElement.jsonModel.presence != "hidden" && edgeElement.jsonModel.presence !="invisible") {
                cssStyleObj['border'+str+'width'] = this._subPixelValue(this._convertToPx(edgeElement.getAttribute('thickness'))) || "1px";
                if(edgeElement.getElement("color") && edgeElement.getElement("color").getAttribute("value") !="")  {
                    var color =   edgeElement.getElement("color").getAttribute("value");
                    color = "rgb(" + color + ")";
                    cssStyleObj['border'+str+'color']   = color  ;
                }
                else {
                    cssStyleObj['border'+str+'color'] = "rgb(0,0,0)"  ;
                }
                cssStyleObj['border'+str+'style']   = style[edgeElement.getAttribute('stroke')] || "solid" ;
            } else {
                cssStyleObj['border'+str+'width'] =  "0px";
                return 1;
            }

        },

        getStyleForBorder : function (border) {
            if(border) {
                var edge  =  border.getElement('edge', 0, true),
                    edge1 = border.getElement('edge', 1, true),
                    edge2 = border.getElement('edge', 2, true),
                    edge3 = border.getElement('edge', 3, true);
                if(edge || edge1 || edge2 || edge3) {
                    var cssStyleObj = {} ;
                    var e0 = this.getStyleForEdge(edge, "-top-",cssStyleObj);
                    var e1 = this.getStyleForEdge(edge1 || edge,"-right-",cssStyleObj);
                    var e2 = this.getStyleForEdge(edge2|| edge,"-bottom-",cssStyleObj);
                    var e3 = this.getStyleForEdge(edge3 || edge,"-left-",cssStyleObj);
                    if(e0 !=1|| e1 !=1|| e2 !=1|| e3!=1)
                        return cssStyleObj ;
                }
            }
                return null;
        },

        _convertToPx : function(size){
            if(!size)
                return 0;
            size = "" + size;
            var pxSize = size;
            if(size.indexOf("in") >=0){
                pxSize = this._mm2px(parseFloat(size) * this._in2mmFactor);
            }
            else if(size.indexOf("mm") >=0){
                pxSize = this._mm2px(size);
            }
            else if(size.indexOf("cm") >=0){
                pxSize = this._mm2px(parseFloat(size) * 10);
            }
            else if(size.indexOf("pt") >=0){
                pxSize = parseFloat(size) * (this._deviceResolution/this._pdfResolution);
            }
            else if(size.indexOf("px") >=0){
                pxSize = parseFloat(size);
            }
            return pxSize;
        },

        _mm2px : function(mmSize){
            var mmSizeNum = 0;
            if(_.isNumber(mmSize))
                mmSizeNum = mmSize;
            else{
                mmSizeNum = parseFloat(mmSize)
            }
            var mm2in = 1/25.4 ;
            var pxSize = mmSizeNum*mm2in*this._deviceResolution;
            return pxSize;
        },

        _subPixelValue : function(value){
            if(value > 0.01)
                return Math.max(value, 1.0);
            else
                return value;
        }
    }
})(_, $, xfalib);
/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2017 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/




(function(_, $, xfalib){
    xfalib.view.util.traversalManager = {

        // compute tabIndex for the provided page
        _computTabIndex : function (pageView) {
            var pageNum = pageView._pageNumber(),
                tabIndex = this._tabIndexBasedOnRange(pageNum);
            this.geographicalOrder = [];
            this._createGeographicalOrder(pageView);
            this._createFinalTraversalOrder(tabIndex); // assign tab index using traversal element and geographicalOrder
            // keep tracks of the last field on the page to get tab index so that handler to render next page can be added on getting focus through tabbing
            this._lastFieldTabbed = null;
        },

        _tabIndexBasedOnRange : function (pageNum) {
            var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]),
                tabIndexConfig = (behaviorConfig.isOn('mfRangeTabIndex')|| behaviorConfig.isOn('rangeTabIndex')),
                /*assuming single page can not have more than 1000 fields.[index -> 0 to 999]
                  this is also configurable by passing the maximum number of fields allowable in the page
                  in the config parameter */
                maxFieldInPageForTabIndex = tabIndexConfig? parseInt(tabIndexConfig):1000;

            return pageNum * maxFieldInPageForTabIndex;
        },

        // to create geographical order array which will be containing all the views in the geographical order
        _createGeographicalOrder : function (currentView) {
            var sortedChildViewWrapper = this._sortViewGeographically(currentView.childViews);
            _.each(sortedChildViewWrapper, function (wrapper) {
                var currentView = wrapper.view,
                    instanceCheckMap = this._getMapOfInstanceCheck(currentView),
                    isViewEligibleForTabbing = this._isViewEligibleForTabbing(currentView);
                //  If the child view is fieldView, drawView, exclGroupView or subformView then we will push these views in this.geographicalOrder array,
                //  as we need their traverse object during final traversing
                if (((instanceCheckMap.isField && !instanceCheckMap.isChildOfExclGroup) || instanceCheckMap.isSubform || instanceCheckMap.isDraw
                    || instanceCheckMap.isExclGroup) && isViewEligibleForTabbing) {
                    this.geographicalOrder.push({
                        view : currentView,
                        visited : false
                    });
                }
                if (instanceCheckMap.isContainer && isViewEligibleForTabbing) {
                    this._createGeographicalOrder(currentView);
                }
            }, this);
        },

        // to sort provided views in geographical order
        _sortViewGeographically : function (views) {
            var viewsWrapper = [];   // wrapper of view and their geographical reference
            _.each(views, function(view) {
                var position = view.$el.offset(),
                    paddedX = xfalib.ut.XfaUtil.prototype.padString(parseInt(position.left), 5, '0'),
                    marginTop = view._marginTop(),
                    paddedY = position.top - parseFloat(marginTop),
                    positionalReference = parseInt("" + parseInt(paddedY) + paddedX);
                viewsWrapper.push({
                    positionalReference: positionalReference,
                    view: view
                });
            });
            return _.sortBy(viewsWrapper, function(viewWrapper){ return viewWrapper.positionalReference; });
        },

        // Walk through views in geographical order and assign tab index honouring traversal object if present
        _createFinalTraversalOrder : function (tabIndex) {
            var geographicalOrderLength = this.geographicalOrder.length,
                currentWrappedObj = null,
                index = -1,
                traversalIndex = 0,  // index of the element to be traversed
                viewTraversed = 0;  // counter of view traversed

            while (1) {
                if (traversalIndex >= geographicalOrderLength) {
                    traversalIndex = 0;
                }
                currentWrappedObj = this.geographicalOrder[traversalIndex];

                if (!currentWrappedObj || currentWrappedObj.visited) {  // if the wrapped object does not exist or it has been visited move to the next one
                    traversalIndex++;
                } else {
                    currentWrappedObj.visited = true;
                    viewTraversed++;
                    var currentView = currentWrappedObj.view,
                        instanceCheckMap = this._getMapOfInstanceCheck(currentView),
                        currentModel = currentView.model,
                        nextView = null,
                        nextViewSom = null;

                    // get the first traversal of the subform if traversal object is present, else move to the next geographical element
                    // next of the subform will be taken care when we will be finding the next view to be traversed,
                    // as we will be checking if the ancestor contain next before moving to geographically next view
                    if (instanceCheckMap.isSubform) {
                        if (currentModel && currentModel.getTraversalObject()) {
                            // get the first element to be traversed and update traversalIndex
                            nextViewSom = currentModel.getNextTraversalSom(xfalib.template.Constants.firstTraversal);
                            index = this._findViewInGeographicalOrderArray(nextViewSom);
                            traversalIndex = index != -1 ? index : traversalIndex + 1;
                        } else {
                            traversalIndex++;
                        }
                    // get the next traversal for the field/draw if traversal object is present, else move to the next geographical element
                    // update the tabindex for the field
                    } else if (instanceCheckMap.isField || instanceCheckMap.isDraw) {
                        if (instanceCheckMap.isField) {
                            currentView.updateTabIndex(tabIndex);
                            this._lastFieldTabbed = currentView;
                            tabIndex++;
                        }
                        if (currentModel && currentModel.getTraversalObject()) {
                            //get next element to be traversed and update traversalIndex
                            nextViewSom = currentModel.getNextTraversalSom(xfalib.template.Constants.nextTraversal);
                            index = this._findViewInGeographicalOrderArray(nextViewSom);
                            traversalIndex = index != -1 ? index : traversalIndex + 1;
                        } else {
                            traversalIndex = this._findNextViewToBeTraversed(traversalIndex);
                        }
                    // if traversal object present get the next element to be traversed, if first is also present then update tab index of the first element
                    // else look for the traversal element in the children
                    } else if (instanceCheckMap.isExclGroup) {
                        if (currentModel && currentModel.getTraversalObject()) {
                            // get next element to be traversed and update traversalIndex
                            nextViewSom = currentModel.getNextTraversalSom(xfalib.template.Constants.nextTraversal);
                            index = this._findViewInGeographicalOrderArray(nextViewSom);
                            traversalIndex = index != -1 ? index : traversalIndex + 1;
                            // if first is also present assign tab index to that referred child else assign same tab index to all child
                            nextViewSom = currentModel.getNextTraversalSom(xfalib.template.Constants.firstTraversal);
                            tabIndex = this._updateTabIndexOfExclGroupChildren(currentView, tabIndex, nextViewSom);
                        } else {
                            tabIndex = this._updateTabIndexOfExclGroupChildren(currentView, tabIndex);
                            traversalIndex = this._findTraversalInExclGroupChildren(currentView, traversalIndex);
                        }
                    } else {
                        traversalIndex++;
                    }
                }

                // if all the view are traversed, we have assigned tab index to all the views
                if (viewTraversed >= geographicalOrderLength) {
                    this._renderNextPageFuture();
                    break;
                }
            }
        },

        // Check if the nextView is a sibling of the currentView (shares the same parent)
        // if it is not a sibling, check if the parent has a NEXT traversal.
        // if so get the node traversed to else recurse to see if nextView is a sibling of our parent
        // return -1 if the provided next node is sibling of current node or if no ancestor contain next traversal
        // else return index of the next traversal object of parent
        _getParentNextTraversal : function (currentView, nextView, traversalIndex) {
            var parentView = currentView.parentView,
                parentModel = parentView.model,
                nextViewParentModel = nextView.parentView.model,
                traversalObj = null,
                nextIndex = -1;

            if (parentModel && nextViewParentModel && parentModel.somExpression != nextViewParentModel.somExpression) {
                if(parentView && parentView instanceof xfalib.view.SubformView) {
                    if (parentModel.getTraversalObject()) {
                        var nextViewSom = parentModel.getNextTraversalSom(xfalib.template.Constants.nextTraversal);
                        nextIndex = this._findViewInGeographicalOrderArray(nextViewSom);
                        if (nextIndex != -1 && !this.geographicalOrder[nextIndex].visited) {
                            return nextIndex;
                        } else {
                            return traversalIndex++;
                        }
                    } else {
                        this._getParentNextTraversal(parentView, nextView, traversalIndex);
                    }
                } else {  // parentView is not a subform so skip up a level and re-check sibling
                    this._getParentNextTraversal(parentView, nextView, traversalIndex);
                }
            } else {
                return -1;  //provided currentView and nextView are sibling
            }
            return traversalIndex++;
        },

        // return the index of the view having provided somExpression in the geographicalOrder array
        _findViewInGeographicalOrderArray : function (somExpression) {
            return _.findIndex(this.geographicalOrder, function (viewWrapper) {
                var currentViewModel = viewWrapper.view.model;
                return (currentViewModel && currentViewModel.somExpression == somExpression);
            });
        },

        // find the next element to be traversed based on the provided traversalIndex
        _findNextViewToBeTraversed : function (traversalIndex) {
            var currentView = this.geographicalOrder[traversalIndex].view,
                index = this._getNextUnvisited(traversalIndex),   //get next unvisited based on geographical location
                nextView = null,
                nextIndex = -1;

            if (index != -1) {
                nextView = this.geographicalOrder[index].view;
                //check if both are sibling and if not find the next of the parent and update traversalIndex
                nextIndex = this._getParentNextTraversal(currentView, nextView, traversalIndex);
                return nextIndex != -1 ? nextIndex : index;
            }
            return traversalIndex++;
        },

        // return the next unvisited node based on geographical location
        // starting from the traversalIndex and wraps around to check all the views
        _getNextUnvisited : function (traversalIndex) {
            var geographicalOrderLength = this.geographicalOrder.length,
                index = 0,
                actualIndex = 0;
            while(index < geographicalOrderLength) {
                actualIndex = (index + traversalIndex) % geographicalOrderLength;
                if(!this.geographicalOrder[actualIndex].visited) {
                    return actualIndex;
                }
                index++;
            }
            return -1;
        },

        // assign same tab index to all the child of exclude group
        // if exclude group contain first traverse object, then the child being referred as first should have less tabindex
        // compared to other child
        _updateTabIndexOfExclGroupChildren : function (exclGroupView, tabIndex, firstChildSom) {
            _.each(exclGroupView.childViews, function(child){
                if (this._isViewEligibleForTabbing(child)) {
                    if(firstChildSom && child.model.somExpression == firstChildSom) {
                        tabIndex++;
                        child.updateTabIndex(tabIndex-1);
                        this._lastFieldTabbed = child;
                    } else {
                        child.updateTabIndex(tabIndex);
                    }
                }
            }, this);
            if (!firstChildSom) {
                this._lastFieldTabbed = exclGroupView.childViews[0];
            }
            return ++tabIndex;
        },

        // find if any child contains next pointer and update traversal index
        // start with the last in the geographical order of the children and find child which have next traversal
        _findTraversalInExclGroupChildren : function (exclGroupView, traversalIndex) {
            var sortedChildView = this._sortViewGeographically(exclGroupView.childViews),
                tempObj = null,
                childView = null,
                childModel = null,
                traversalObj = null,
                nextViewSom = null,
                index = -1;

            sortedChildView.reverse();
            tempObj = _.find(sortedChildView, function(child) {
                childView = child.view;
                childModel = childView.model;
                if(childModel && (traversalObj = childModel.getTraversalObject())) {
                    return traversalObj.length > 0;
                }
            });

            if (tempObj) {
                nextViewSom = tempObj.model.getNextTraversalSom(xfalib.template.Constants.nextTraversal);
                index = this._findViewInGeographicalOrderArray(nextViewSom);
                traversalIndex = index != -1 ? index : traversalIndex + 1;
            } else { // else get next unvisited based on geographical location
                traversalIndex = this._findNextViewToBeTraversed(traversalIndex);
            }
            return traversalIndex;
        },

        // check if the view is initialized and visible
        _isViewEligibleForTabbing : function (view) {
            if (view._initialized && view.$el.css("visibility") != "hidden") {
                return true;
            }
            return false;
        },

        // return map of whethter provided view is instance of the various views
        _getMapOfInstanceCheck : function (view) {
            var instanceCheckMap = {};
            instanceCheckMap.isSubform = view instanceof xfalib.view.SubformView;
            instanceCheckMap.isField = view instanceof xfalib.view.FieldView;
            instanceCheckMap.isDraw = view instanceof xfalib.view.XfaDrawView;
            instanceCheckMap.isExclGroup = view instanceof xfalib.view.ExclGroupView;
            instanceCheckMap.isChildOfExclGroup = view.parentView instanceof xfalib.view.ExclGroupView;
            instanceCheckMap.isContainer = view instanceof xfalib.view.ContainerView;

            return instanceCheckMap;
        },

        // add event handler for rendering next page on tabbing on last field of the page
        _renderNextPageFuture : function () {
            if (this._lastFieldTabbed) {
                this._lastFieldTabbed.$el.one('focusin.traversalManager', function() {
                    var pagingManager = window.formBridge ? window.formBridge.pagingManager() : null;
                    $(window).on( "keyup.traversalManager", function (e) {
                        var code = (e.keyCode ? e.keyCode : e.which);
                        if (code == 9 && pagingManager && pagingManager.hasMorePages()) {
                            pagingManager.renderNextPage();
                            $(window).off("keyup.traversalManager");
                        }
                    });
                });
            }
        },
        _destroy : function() {
            this.geographicalOrder = null;
        }
    }
})(_, $, xfalib);
/*************************************************************************
*
* ADOBE CONFIDENTIAL
* ___________________
*
*  Copyright 2013 Adobe Systems Incorporated
*  All Rights Reserved.
*
* NOTICE:  All information contained herein is, and remains
* the property of Adobe Systems Incorporated and its suppliers,
* if any.  The intellectual and technical concepts contained
* herein are proprietary to Adobe Systems Incorporated and its
* suppliers and are protected by trade secret or copyright law.
* Dissemination of this information or reproduction of this material
* is strictly forbidden unless prior written permission is obtained
* from Adobe Systems Incorporated.
**************************************************************************/



(function(_, $, xfalib){

    var ErrorManager = xfalib.view.util.ErrorManager = xfalib.ut.Class.extend({

        options: {
            warningMessageVisible:false,
            errorMessageVisible: false
        },

        initialize: function () {
            $(window).on("destroy.xfa", function () {
                $("#error-msg").hide();
                $("#warning-msg").hide();
            });
        },

        onFieldEnter: function (jqWidget) {
            var element = jqWidget.element;
            if (jqWidget.option("errorMessage")|| jqWidget.option("warningMessage")) {
                var pos = $(element).offset(),
                    styles = {};
                styles.left = (pos.left * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) + element.width() + 5) + "px";
                styles.top = pos.top * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) + "px";
                if (jqWidget.option("errorMessage")) {
                    jqWidget.$css($("#error-msg").get(0), styles);
                    $("#error-msg").text(jqWidget.option("errorMessage")).show();
                    jqWidget.option("errorMessageVisible",true);
                }
                else if (jqWidget.option("warningMessage")) {
                    jqWidget.$css($("#warning-msg").get(0), styles);
                    $("#warning-msg").text(jqWidget.option("warningMessage")).show();
                    jqWidget.option("warningMessageVisible",true);
                }
            }
        },

        onFieldExit: function (jqWidget) {
            if (jqWidget.option("errorMessageVisible")) {
                $("#error-msg").hide();
                jqWidget.option("errorMessageVisible",false);
            } else if (jqWidget.option("warningMessageVisible")) {
                $("#warning-msg").hide();
                jqWidget.option("warningMessageVisible",false);
            }
        },

        markError: function (jqWidget, msg, type) {
            // assigning role="alert" so that JAWS reads-out the validation message
            if (type != "warning") {
                if ($("#error-msg").length < 1)
                    $("<div id='error-msg' role='alert'></div>").appendTo('body');
                jqWidget.option("errorMessage",msg);
                jqWidget.element.addClass("dataInvalid");
            } else {
                if ($("#warning-msg").length < 1)
                    $("<div id='warning-msg' role='alert'></div>").appendTo('body');
                jqWidget.option("warningMessage",msg);
            }

        },

        clearError: function (jqWidget) {
            this.onFieldExit(jqWidget);
            jqWidget.element.removeClass("dataInvalid");
            jqWidget.option("errorMessage",null);
            jqWidget.option("warningMessage",null);
        }
    });
})(_, $, xfalib);
(function(_,$, xfalib) {
    var xfaUtil = xfalib.ut.XfaUtil.prototype,
        BUFFER_SPC = 20;

    /* template for the clear Button */
    var clearButtonTemplate = '<div class="dp-clear">' +
        '<a></a>' +
        '</div>';

    /* template for the calendar
    * header contains the navigation icons (left and right arrows)
    * and the current caption (which can be date, year or month)
    *
    * monthview displays the grid for showing the dates for a particular
    * month
    *
    * yearview displays all the months of that year
    *
    * yearsetview displays a grid of 16 years. This can be configured
    * through the option: yearsPerView
    *
    */
    var calendarTemplate = '<div class="dp-header">' +
        '<div class="dp-leftnav"></div>' +
        '<div class="dp-caption"></div>' +
        '<div class="dp-rightnav"></div>' +
        '</div>' +
        '<div role="table" class="view dp-monthview"></div>' +
        '<div role="table" class="view dp-yearview"></div>' +
        '<div role="table" class="view dp-yearsetview"></div>';

    /*template for the timer: not implemented yet */
    var watchTemplate = '<div class="dp-header">' +
        '<div class="dp-leftnav"></div>' +
        '<div class="dp-caption"></div>' +
        '<div class="dp-rightnav"></div>' +
        '</div>' +
        '<div class="view dp-monthview"></div>' +
        '<div class="view dp-yearview"></div>' +
        '<div class="view dp-yearsetview"></div>';

    /** default configuration options
     *
     * container: the html element where the datepicker template will be added
     *
     * yearsPerView: number of years to show in the yearset view
     *
     * width: with of the widget
     *
     * viewHeight: Height of the month,year and yearset view. This doesn't include
     *             the height of the header
     *
     * locale: locale information for the locale in which to show the datepicker which comprises of
     *        days: day names to display in the monthview
     *        months: month names to display in the yearview
     *        zero: string representation of zero in the locale. Numbers will be
     *              displayed in that locale only
     *        clearText: Text to display for the reset button
     *        name: name of the locale
     *
     * format: input format for the datepicker (not implemented)
     *
     * pickerType: type of the datetimepicker (date, datetime and time)
     *
     * positioning: element around which datepicker will be displayed. if null then it
     *              will be displayed around the input element
     *
     * showCalendarIcon: to show the Calendar on the right of the text field or not
     */

    var defaults = {
        container: "body",
        yearsPerView: 16,
        width: 340,
        viewHeight: 248,
        locale: {
            days:["S","M","T","W","T","F","S"],
            months: ["January","February","March","April","May","June","July","August","September","October","November","December"],
            zero: "0",
            clearText: "Clear",
            name:"en_US"
        },
        format:"YYYY-MM-DD",
        pickerType:"date",
        positioning: null,
        showCalendarIcon: false
    },
    dates = [31,28,31,30,31,30,31,31,30,31,30,31],
    /*
     *  Actions to perform when clicked on the datepicker buttons
     *  for different views
     *  caption: view to show when clicked on caption
     *           (Year/YearSet/Month/null) null means don't change the view
     *  li: view to show when clicked on date, month or year element
     *  upDown: add(up key) or subtract(down key) current date (for monthview),
     *          month(Year View) or year(YearSetView) with the number provided
     *  key: identifies the key that needs to be changed for that view
     */
    viewAction = {
        Month: {
            caption: 'Year',
            li: null,
            key:"day",
            upDown:7
        },
        Year: {
            caption: "Yearset",
            li: "Month",
            key:"month",
            upDown:3
        },
        Yearset: {
            caption: null,
            li: "Year",
            key:"year",
            upDown:4
        }
    },
    headerClass = "header",

    DateTimePicker = function() {
        this.initialized = false;
    }

    $.extend(DateTimePicker.prototype, {
        /*
         * create the widget using the provided options
         */
        create: function(options) {
            var $dp,self = this,html="",prevNavWidth,nextNavWidth;
            if (window.FD && window.FD.isToggleEnabled("FT_FORMS-13599")) {
                    defaults.width = 433;
                }
            this.options = $.extend({},defaults,options);
            // prevent memory leak since options.positioning holds reference to HTML DOM
            this.options.positioning = null;
            // If width of date-picker exceeds screen width then it'll take up the entire screen width in AF
            if(window.guideBridge && this.options.width > window.innerWidth && window.innerWidth > 0) {
               this.options.width=window.innerWidth - BUFFER_SPC; // buffer
            }
            if(this.options.pickerType.match(/date/)) {
                html += calendarTemplate;
            }

            if(this.options.pickerType.match(/time/)) {
                html += watchTemplate;
            }

            html += clearButtonTemplate;

            $.extend(this, {
                selectedDay:0,
                selectedMonth:0,
                selectedYear:0,
                currentDay:0,
                currentMonth:0,
                currentYear:0,
                touchSupported : xfalib.ut.TouchUtil.TOUCH_ENABLED,
                _visible:false,
                _defaultView:"Month",
                _keysEnabled:false,
                focusedOnDatepickerItem : false,
                keyboardAccessibility : true,
                $dp:$("<div></div>").addClass("datetimepicker")
                                    .width(this.options.width)
                                    .append(html)
                                    .addClass("datePickerTarget")
                                    .appendTo(this.options.container)
                                    .toggleClass("datetimepicker-notouch",this.touchSupported),
                $month: $(".dp-monthview",this.$dp).height(this.options.viewHeight),
                $year: $(".dp-yearview",this.$dp).height(this.options.viewHeight),
                $yearset : $(".dp-yearsetview",this.$dp).height(this.options.viewHeight)
            });
            this.actualWidth = Math.floor(this.$dp.width());
            this.$clear = $('.dp-clear a', this.$dp).on("click", $.proxy(this._clearDate, this));
            this.$prevNavWidthBtn = $(".dp-leftnav", this.$dp).on("click",
                                                            function(evnt) {
                                                                self._adjustDate(-1, self.view, false)
                                                            });
            this.$nextNavWidthBtn = $(".dp-rightnav", this.$dp).on("click",
                                                            function(evnt) {
                                                                self._adjustDate(1, self.view, false)
                                                            });
            prevNavWidth = this.$prevNavWidthBtn.outerWidth(true);
            nextNavWidth = this.$nextNavWidthBtn.outerWidth(true);
            this.$caption = $(".dp-caption", this.$dp).width(this.actualWidth - prevNavWidth - nextNavWidth)
                                                     .on("click",
                                                            function(evnt) {
                                                                if(!self.$caption.hasClass("disabled")) {
                                                                    self._layout(viewAction[self.view].caption);
                                                                }
                                                      });
            if (this.keyboardAccessibility) {
                _.each([this.$prevNavWidthBtn, this.$caption, this.$nextNavWidthBtn, this.$clear], function (elem, i) {
                    elem.attr("tabIndex", i + 1);
                });
            }
            // attach click event on entire datePicker popup
            $(this.$dp).on("click",
                function(evnt) {
                    //focus only if the device doesn't support touch
                    // input otherwise on screen keyboard will popup
                    if(!self.touchSupported)
                        self._curInstance.$field.focus();
                });

            $(window).on("touchstart.datetimepicker mousedown.datetimepicker",self._checkWindowClicked);
            this._curInstance = null;
        },

        /*
         * attaches the date picker to the field. This is a one time operation
         * First creates a configuration object and stores it in the field data attributes
         * then attaches event handlers on click, focus (to show the picker) and blur (to hide) events
         */
        _attachField: function($field,options, value) {
            var inst = this._newInst($field,options, value),
                self = this,
                activateField = function(evnt) {
                    var data = xfaUtil.$data(evnt.target,"datetimepicker");
                    if(data.access == false) {
                        return;
                    }
                    if(!self._curInstance)
                         self._activateField(evnt);

                    if(self.options.showCalendarIcon) {
                        if (evnt.type === self.getEvent()) {
                            if (self._iconClicked) {
                                self._iconClicked = false;
                                if (self._visible) {
                                    self._hide(); // hide the calendar popup if visible when calendar icon is clicked
                                    self._curInstance.$field.focus(); // bring back focus in field
                                } else {
                                    self._show(); //// show the calendar popup if not visible when calendar icon is clicked
                                }
                            }
                        }
                    } else {
                        /*show the popup only if
                         1. click/touch event
                         2. focus event in case of non-touch devices and focus is not done using script
                         */
                        if (evnt.type === self.getEvent() || (evnt.type === "focus" && !self.touchSupported && !self.scriptFocus)) {
                            self._show(evnt);
                        }
                    }

                    self._clickedWindow = true;
                    self.scriptFocus = false;
                },
                deactivateField = function(evnt) {
                    //deactivate only if clicked outside window
                    // on touch devices only keyboard or calander should be active at once, touching keyboard should deactivate calendar
                    if ((self._clickedWindow && !self.focusedOnDatepickerItem) && (self.options.showCalendarIcon || !self.touchSupported)) {
                        self._hide();
                        self._deactivateField();
                        self._clickedWindow = true;
                    }
                };

            xfaUtil.$data($field[0],"datetimepicker",inst);

            $field.on(this.getEvent(),activateField)
                  .focus(activateField)
                  .blur(deactivateField);
            if(options.showCalendarIcon) {
                var calendarIcon = $("<div></div>")
                                    .addClass("datepicker-calendar-icon")
                                    .css({
                                        "width": options.iconWidth + "px",
                                        "height": options.iconHeight + "px"
                                    });
                calendarIcon.insertAfter($field);

                if (this.keyboardAccessibility) {
                    calendarIcon.attr("tabindex", 0);
                }

                calendarIcon.on(this.getEvent(), function (evnt) {
                                self._iconClicked = true;
                                $field.click();
                              })
                              .on("keydown", function (event) {
                                    if (event.keyCode === 32 || event.keyCode === 13) {
                                        $field.click();
                                    }
                              });
            }
        },

        _newInst: function($f,options, value) {
            return {
                $field:$f,
                locale: options.locale,
                positioning: options.positioning || $f,
                access:options.access,
                selectedDate:options.value,
                editValue :options.editValue,
                minValidDate : options.minValidDate,
                maxValidDate : options.maxValidDate,
                exclMinDate :  options.exclMinDate,
                exclMaxDate : options.exclMaxDate
            }
        },

        /*
         * To check where the click happened, if happened outside the datepicker
         * then hide the picker. This is checked whether any ancestor of clicked target
         * has a class datePickerTarget. This class is added to the attached element as well
         */
        _checkWindowClicked : function(evnt) {
            var self = adobeDateTimePicker;
            if(self._curInstance) {
                // datepickerTarget class depicts that the component is a part of the Date Field
                // and on click of that class, we should not hide the datepicker or fire exit events.
                if(!$(evnt.target).closest(".datePickerTarget").length) {
                    //non-touch devices do not deactivate on blur. Hence needs to be done here
                    if(self.touchSupported) {
                        self._hide()
                        //clicking outside a field doesn't blur the field in IPad. Doing it by script
                        self._curInstance.$field[0].blur()
                        self._deactivateField()
                    } else{
                        self._clickedWindow = true;
                        // set focusedOnDatepickerItem to false, it hides the datepicker see method deactivateField.
                        self.focusedOnDatepickerItem = false;
                        self._curInstance.$field.blur()
                    }
                }
                else {
                    self._clickedWindow = false;
                }
            }
        },

        /*
         * handling of key strokes. All the key strokes prevent the default browser action
         * unless specified otherwise
         * tab: set focus on calendar icon when dateinput field is active, navigates through date picker buttons when datepicker is open,
         * otherwise perform default browser action
         * escape: hides the datepicker
         * down arrow key: navigate the picker downwards by the number specified in actionView.upDown of the current View
         * up arrow key: navigate the picker upwards by the number specified in actionView.upDown of the current View
         * left arrow key: navigate the picker one unit of that view backward
         * right arrow key: navigate the picker one unit of that view forward
         * shift + up: perform the action that happens on clicking the caption (as specified in actionView.caption)
         * shift + left: perform the action that happens on clicking the left navigation button
         * shift + right: perform the action that happens on clicking the right navigation button
         * space/enter: triggers the click event for the current focused element from datepicker/ opens datepicker when calendar icon is focused.
         */
        _hotKeys: function(evnt) {
            var handled = false, date;
            switch(evnt.keyCode) {
                case 9: //tab
                    // CQ-4239352 : Setting clickedWindow property to true on tabbing so that deactivateField logic gets executed
                    // When clicking on "x" on input field in in IE and when selecting the content and releasing the mouse select outside the field
                    // the click event is not trigerred on the field and hence activateField is not executed, so clickedWindow remains as false
                    adobeDateTimePicker._clickedWindow = true;
                    handled = false;
                    break;
                case 27://escape
                    if(this._visible) {
                        adobeDateTimePicker._hide();
                        this._curInstance.$field.focus();
                        handled = true;
                    }
                    break;
                case 32: //space
                case 13: // enter
                    if($(evnt.target).hasClass("datepicker-calendar-icon")){
                        if(!this._visible) {
                            this._show();
                            return;
                        }
                        this.$focusedDate.addClass("dp-focus");
                    }
                    break;
                case 40: //down arrow key
                    if(!this._visible) {
                        this._show();
                        return;
                    }
                    this.$focusedDate.addClass("dp-focus");
                    break;
            }

            if(adobeDateTimePicker._visible && this._keysEnabled) {
                var v = viewAction[this.view].key,
                    updown=viewAction[this.view].upDown;
                switch(evnt.keyCode) {
                    case 9: // tab
                        if (evnt.shiftKey) {
                            if ($(evnt.target).hasClass("dp-leftnav") || $(evnt.target).hasClass("dp-focus")) {
                                this._hide();
                                this._curInstance.$field.focus();
                                handled = true;
                            } else {
                                handled = false;
                            }
                        } else {
                            var buttonTabindex = $(evnt.target).attr("tabindex");
                            if (buttonTabindex === '0') {
                                if (evnt.target.tagName.toLocaleLowerCase() === "input") {
                                    this._hide();
                                    handled = false;
                                } else {
                                    this.$prevNavWidthBtn.focus();
                                    handled = true;
                                }
                            } else if (buttonTabindex === '4') {
                                this._hide();
                                this._curInstance.$field.focus();
                                handled = true;
                            } else {
                                handled = false;
                            }
                        }
                        break;
                    case 32: //select on space
                    case 13: // select on enter
                        this.hotKeyPressed = true;
                        this.focusedOnDatepickerItem = false;
                        if (!this.focusedOnDatepickerItem) {
                            $(evnt.target, this.$dp).triggerHandler("click");
                        } else {
                            if (this.$focusedDate) {
                                this.$focusedDate.trigger("click");
                            }
                        }
                        this.hotKeyPressed = false;
                        handled = true;
                        break;
                    case 37: //left arrow key
                        if (evnt.shiftKey) {
                            $(".dp-leftnav", this.$dp).triggerHandler("click");
                        } else {
                            this._adjustDate(-1, v, true);
                        }
                        handled = true;
                        break;
                    case 38: //up arrow key
                        if (evnt.shiftKey) {
                            this.$caption.triggerHandler("click");
                        } else {
                            this._adjustDate(-updown, v, true);
                        }
                        handled = true;
                        break;
                    case 39: //right arrow key
                        if (evnt.shiftKey) {
                            $(".dp-rightnav", this.$dp).triggerHandler("click");
                        } else {
                            this._adjustDate(+1, v, true);
                        }
                        handled = true;
                        break;
                    case 40: //down arrow key
                        this._adjustDate(updown, v, true);
                        handled = true;
                        break;
                    default:
                }
            }
            if(handled) {
                evnt.preventDefault();
            }
        },

        /*
         * show the datepicker.
         */
        _show: function() {
            if(this._curInstance.access == false)
                return;
            this.options.locale = this._curInstance.locale;
            if(!this._visible) {
                var self = this,
                    date = new Date(),
                    val,
                    maxDateInfo,
                    minDateInfo,
                    validDate;
                //Bug#3607735:
                // Date constructor in ipad 5.1 doesn't support "YYYY-MM-DD", hence parsing the date on our own
                validDate = xfalib.ut.DateInfo.ParseIsoString(this._curInstance.selectedDate);
                date = (validDate != null)? validDate.getDate(): new Date();
                this.selectedDay = this.currentDay = date.getDate();
                this.selectedMonth = this.currentMonth = date.getMonth();
                this.selectedYear = this.currentYear = date.getFullYear();
                maxDateInfo = this.options.maxValidDate ? xfalib.ut.DateInfo.ParseIsoString(this._curInstance.maxValidDate) : null;
                this.maxValidDate = maxDateInfo ? maxDateInfo.getDate() : null;
                minDateInfo = this.options.minValidDate ? xfalib.ut.DateInfo.ParseIsoString(this._curInstance.minValidDate) : null;
                this.minValidDate = minDateInfo ? minDateInfo.getDate() : null;
                this.exclMaxDate = this._curInstance.exclMaxDate;
                this.exclMinDate = this._curInstance.exclMinDate;
                $('.dp-clear a',this.$dp).text(this.options.locale.clearText);
                this._layout('Month');
                this._position();
                this.$dp.show();
                // if li element of datepicker is focused then set focusedOnDatepickerItem to true, it manages the visibility of the datepicker.
                this.focusedOnDatepickerItem = false;
                this._visible = true;
                if (this.options.showCalendarIcon) {
                    this._curInstance.$field.attr('readonly', true);    // when the datepicker is active, deactivate the field
                }
            }

            //   Disabling the focus on ipad  due to a bug where value of
            // date picker is not being set
            // Removing this code will only hamper one use case
            // where on ipad if you click on the calander then
            // the field becomes read only so
            // there is no indication where the current focus is
            // And  if you remove this foucs code all together
            // then what happens is that on desktop MF in iframe the exit event
            // is not getting called hence calander getting remained open even
            // when you click somewhere on window or focus into some other field
            if (this.options.showCalendarIcon  && !this.touchSupported) {
                if(this.$focusedDate.length > 0) {
                    this.$focusedDate.focus();  // shift focus on current date or selected date.
                } else {
                    this._curInstance.$field.focus(); // field loses focus after being marked readonly, causing blur event not to be fired later
                }
            }
        },

        /*
         * position the datepicker around the positioning element
         * provided in the options
         */
        _position: function() {
            var $elem = this._curInstance.positioning,
                windowScrollX = window.scrollX/ xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowScrollY = window.scrollY/ xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowInnerHeight = window.innerHeight/ xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowInnerWidth = window.innerWidth/ xfalib.ut.XfaUtil.prototype.formScaleFactor,
                height = $elem.outerHeight(true),
                width  = $elem.outerWidth(true),
                top = $elem.offset().top / xfalib.ut.XfaUtil.prototype.formScaleFactor + height,
                left = $elem.offset().left / xfalib.ut.XfaUtil.prototype.formScaleFactor,
                styles = {"top": (top+"px"), "left": (left+"px")},
                diffBottom = top + this.$dp.outerHeight(true) - windowInnerHeight - windowScrollY,
                newLeft,
                newTop;
            if(diffBottom > 0) {
                //can't appear at the bottom
                //check top
                newTop = top - height - this.$dp.outerHeight(true) - BUFFER_SPC;
                if(newTop < windowScrollY) {
                    //can't appear at the top as well ... the datePicker pop up overlaps the date field
                    newTop = top - diffBottom;
                    // Fix for BUG #3626974
                    if(xfaUtil.isWebkit() && !this.options.showCalendarIcon) {
                        this._curInstance.$field.trigger("onoverlap.datetimepicker");
                    }
                }
                styles.top = newTop + "px";
            }
            if(left + this.$dp.outerWidth(true) > windowScrollX + windowInnerWidth ) {
                //align with the right edge
                newLeft = windowScrollX + windowInnerWidth - this.$dp.outerWidth(true) - BUFFER_SPC;
                styles.left = newLeft + "px";
            }
            xfaUtil.$css(this.$dp.get(0), styles);
            return this;
        },

        /*
         * layout the nextView. if nextView is null return
         *
         */
        _layout: function(nextView) {
            if(nextView == null) {
                this._hide();
            } else {
                if(this.view)
                    this['$'+this.view.toLowerCase()].hide();
                this.view = nextView;
                this.$caption.toggleClass("disabled",!viewAction[this.view].caption);
                this['$'+this.view.toLowerCase()].show();
                this["show"+this.view]();
            }
            return this;
        },

        /*
         * show the month view
         */
        showMonth: function() {
            var self = this,
                curDate = new Date(this.currentYear, this.currentMonth),
                maxDay =   this._maxDate(this.currentMonth),
                prevMaxDay = this._maxDate((this.currentMonth + 11)%12),
                day1 = new Date(this.currentYear,this.currentMonth,1).getDay(),
                data,display;

            this.tabulateView(
                {
                    caption: this.options.locale.months[this.currentMonth] + ", "+ this._convertNumberToLocale(this.currentYear),
                    header:this.options.locale.days,
                    numRows:7,
                    numColumns:7,
                    elementAt: function(row,col) {
                        var day = (row-1)*7 + col - day1 + 1;
                        var monthVal = self.currentMonth + 1;
                        display = self._convertNumberToLocale(day);
                        data = day;
                        if(day < 1) {
                            display = self._convertNumberToLocale(prevMaxDay + day);
                            data = -1;
                            monthVal = self.currentMonth;
                        }
                        else if(day > maxDay) {
                            display = self._convertNumberToLocale(day-maxDay);
                            data = -1;
                            monthVal = self.currentMonth + 2;
                        }
                        else {
                            curDate.setDate(day);
                            var compareFn = xfalib.ut.XfaUtil.prototype._compareVal;
                            // check if the currentdate is valid based on max and min valid date
                            if(compareFn(curDate, self.maxValidDate, self.exclMaxDate) || compareFn(self.minValidDate, curDate, self.exclMinDate)) {
                                data = -1;
                            }
                        }
                        return {
                            data : data,
                            display : display,
                            ariaLabel : self.options.editValue(self.currentYear+"-"+self._pad2(monthVal)+"-"+self._pad2(display))
                        };
                    }
                });
        },



        /*
         * show the year view
         */
        showYear: function() {
            var self = this,
                minDate = this.minValidDate ? new Date(this.minValidDate.getFullYear(), this.minValidDate.getMonth()) : null,
                maxDate = this.maxValidDate ? new Date(this.maxValidDate.getFullYear(), this.maxValidDate.getMonth()) : null,
                curDate = new Date(this.currentYear, 0), //can't omit month, if only one param present it is treated as millisecond
                data,
                month;
            this.tabulateView(
                {
                    caption : this._convertNumberToLocale(this.currentYear),
                    numRows : 4,
                    numColumns : 3,
                    elementAt : function(row,col) {
                        data = month =  row*3 + col;
                        curDate.setMonth(month);
                        if ((minDate && curDate < minDate) || (maxDate && curDate > maxDate)) {
                            data = -1;
                        }
                        return {
                            data : data,
                            display : self.options.locale.months[month],
                            ariaLabel : self.options.locale.months[month] + " " +self.currentYear
                        };
                    }
                });
        },

        /*
         * show the year set view
         */
        showYearset: function() {
            var year,
                minDate = this.minValidDate ? new Date(this.minValidDate.getFullYear(), 0) : null ,
                maxDate = this.maxValidDate ? new Date(this.maxValidDate.getFullYear() + 1, 0) : null,
                curDate = new Date(),
                data,
                self = this;
            this.tabulateView(
                {
                    caption: this._convertNumberToLocale(this.currentYear - this.options.yearsPerView/2) +"-"+this._convertNumberToLocale(this.currentYear - this.options.yearsPerView/2 + this.options.yearsPerView - 1),
                    numRows:4,
                    numColumns:4,
                    elementAt: function(row,col) {
                        data = year =  self.currentYear - 8 + (row*4 + col);
                        curDate.setFullYear(year);
                        if ((minDate && curDate < minDate) || (maxDate && curDate > maxDate)) {
                            data = -1;
                        }
                        return {
                            "data" : data,
                            "display" : self._convertNumberToLocale(year),
                            ariaLabel : year
                        };
                    }
                });
        },

        insertRow :  function(rowNum,rowArray,isHeader,height) {
            var $view = this["$"+this.view.toLowerCase()],
                width = (this.actualWidth)/rowArray.length,
                $row = $("ul",$view).eq(rowNum),
                items,$li,element,$tmp,
                self= this;
            if(!$row.length)
                $row = $("<ul></ul>").attr("aria-label", "").attr("role", "row").appendTo($view).toggleClass(headerClass,isHeader);
            $row.height(height);
            items = $("li",$row).length;
            while(items++ < rowArray.length) {
                $tmp = $("<li></li>").attr("role", "cell").appendTo($row);
                if(!isHeader)
                    $tmp.on("click", $.proxy(this._selectDate,this));
            }

            _.each(rowArray, function(el,index) {
                $li = $("li",$row).eq(index);
                if(isHeader)
                    $li.text(rowArray[index]);
                else {
                    element = rowArray[index];
                    xfaUtil.$data($li.get(0), "value", element.data);
                    if(self._checkDateIsFocussed(element.data)) {
                        if(self.$focusedDate) {
                            self.$focusedDate.removeClass("dp-focus");
                            self.$focusedDate.attr("tabindex", "-1");
                        }
                        self.$focusedDate = $li;
                        if(self._keysEnabled)
                            self.$focusedDate.addClass("dp-focus")
                    }
                    $li.toggleClass("dp-selected",self._checkDateIsSelected(element.data))
                        .toggleClass("disabled", element.data == -1).text(element.display)
                        .attr("title", element.ariaLabel)
                        .attr("aria-label", element.ariaLabel)
                        .attr("tabindex", -1);
                }
                $li.css( {"height":height+"px","width":width+"px","line-height":height+"px"});
            });
            return $row;
        },

        /*
         * creates a tabular view based on the options provided. The options that can be passed are
         * numRows: number of rows that needs rendering
         * numCols: number of columns that needs rendering
         * caption: text for the datepickers caption element
         * header: an array of elements that identifies the header row
         * elementAt: a function(row, column) that returns an object (data: <data>, display: <display>) where
         *            <data> is the value to set for that view when the element at (row,column) is clicked and
         *            <display> is the value that will be visible to the user
         */
        tabulateView : function(options) {
            var r = 0,rows = 0,
                row = [],
                ht =  this.options.viewHeight/options.numRows,
                c;
            this.$caption.text(options.caption);
            if(options.header) {
                this.insertRow(r++,options.header,true,ht);
            }
            while(r < options.numRows) {
                c = 0;
                while(c < options.numColumns) {
                    row[c] = options.elementAt(r,c);
                    c++;
                }
                this.insertRow(r++,row,false,ht);
            }
        },

        _activateField : function(evnt) {
            this._curInstance = xfaUtil.$data(evnt.target,"datetimepicker");
            this._curInstance.$field.trigger("onfocus1.datetimepicker").addClass("datePickerTarget");
            // Issue LC-7049:
            // datepickerTarget should be added when activate the field and should be removed
            // after the fields gets deactivated.
            if (this.options.showCalendarIcon) {
                this._curInstance.$field.parent().addClass("datePickerTarget");
            }
            //enable hot keys only for non touch devices
            if(!this.touchSupported && !this._keysEnabled) {
                $(window).on("keydown.datetimepicker", $.proxy(this._hotKeys,this));
                this._keysEnabled = true;
            }
        },

        _deactivateField: function() {
            if(this._curInstance) {
                if(this._keysEnabled) {
                    $(window).off("keydown.datetimepicker")
                    this._keysEnabled = false;
                }
                //Bug#3607499: on deactivate check the value in the input box, if that is
                // different than the selected Date, change the selectedDate
                //if (this._curInstance.selectedDate != this._curInstance.$field.val()) {
                //    this._curInstance.selectedDate = this._curInstance.$field.val();
                //}
                this._curInstance.$field.trigger("onfocusout.datetimepicker").removeClass("datePickerTarget");
                // Issue LC-7049:
                // datepickerTarget should be added when activate the field and should be removed
                // after the fields gets deactivated. Otherwise clicking on any other datefield
                // will not hide the existing datepicker
                if (this.options.showCalendarIcon) {
                    this._curInstance.$field.parent().removeClass("datePickerTarget");
                }
                this._curInstance = null;
            }
        },

        _hide: function() {
            if(this._visible) {
                this.$dp.hide();
                this._curInstance.$field.trigger("onclose.datetimepicker");
                this._visible = false;
                if (this.options.showCalendarIcon) {
                    this._curInstance.$field.attr('readonly', false);    // when the datepicker is deactivated, activate the field
                }
            }
        },

        _adjustDate: function(step, view, focus) {
            var maxDate,prevMaxDate;
            var _focus = focus || false;
            switch(view.toLowerCase()) {
                case "day":
                    this.currentDay += step;
                    maxDate = this._maxDate(this.currentMonth)
                    if(this.currentDay < 1) {
                        prevMaxDate =  this._maxDate((this.currentMonth - 1 + 12)%12);
                        this.currentDay = prevMaxDate + this.currentDay;
                        return this._adjustDate(-1, "month", _focus);
                    }
                    if(this.currentDay > maxDate) {
                        this.currentDay -= maxDate;
                        return this._adjustDate(+1, "month", _focus);
                    }
                    break;
                case "month":
                    this.currentMonth += step;
                    if(this.currentMonth > 11) {
                        this.currentYear++;
                        this.currentMonth = 0;
                    }
                    if(this.currentMonth < 0) {
                        this.currentYear--;
                        this.currentMonth = 11;
                    }
                    break;
                case "year":
                    this.currentYear += step;
                    break;
                case "yearset":
                    this.currentYear += step*this.options.yearsPerView;
                    break;
            }
            this._layout(this.view);
            if (_focus) {
                this.focusedOnDatepickerItem = true;
                this.$focusedDate.attr("tabindex", 0)[0].focus();
            }
        },

        _checkDateIsSelected: function(data) {
            switch(this.view.toLowerCase()) {
                case "month":
                    return this.currentYear == this.selectedYear && this.currentMonth == this.selectedMonth && data == this.selectedDay;
                case "year":
                    return this.currentYear == this.selectedYear && this.selectedMonth == data;
                case "yearset":
                    return this.selectedYear == data;
            }
        },

        _checkDateIsFocussed: function(data) {
            switch(this.view.toLowerCase()) {
                case "month":
                    return data == this.currentDay;
                case "year":
                    return this.currentMonth == data;
                case "yearset":
                    return this.currentYear == data;
            }
        },

        _convertNumberToLocale : function(number) {
            var zeroCode = this.options.locale.zero.charCodeAt(0);
            number += "";
            var newNumber = [];
            for(var i = 0;i < number.length;i++) {
                newNumber.push(String.fromCharCode(zeroCode + parseInt(number.charAt(i))));
            }
            return newNumber.join("");
        },

        _clearDate: function() {
            var isDateEmpty = this._curInstance.$field.val() ? false : true;
            this.selectedYear
                = this.selectedMonth
                = this.selectedYear
                = -1;
            this._curInstance.selectedDate = "";
            this._curInstance.$field.val("");
            if (!isDateEmpty) {
                this._curInstance.$field.trigger("onvaluechange.datetimepicker", [
                    {selectedDate: ""}
                ]);
            }
            $(".dp-selected",this['$'+this.view.toLowerCase()]).removeClass("dp-selected");
        },

        getEvent : function() {
            return "click";//this.touchSupported ? "touchstart" : "click";
        },

        _pad2: function(m) {
            return m = m < 10 ?"0"+m:m;
        },

        toString : function() {
            return this.selectedYear +"-"+this._pad2(this.selectedMonth + 1)+"-"+this._pad2(this.selectedDay);
        },

        _selectDate : function(evnt) {
            var val = xfaUtil.$data(evnt.target, "value"),
                nextView = viewAction[this.view].li,
                editVal;
            //disabled dates have a value of -1. Do nothing in that case
            if(val == -1)
                return;
            switch(this.view.toLowerCase()) {
                case "month":
                    this.selectedMonth = this.currentMonth;
                    this.selectedYear = this.currentYear;
                    this.selectedDay = val;
                    this._curInstance.selectedDate = this.toString();
                    editVal = this._curInstance.editValue(this.toString());
                    this._curInstance.$field.val(editVal).focus();
                    this._curInstance.$field.trigger("onvaluechange.datetimepicker", [
                        {selectedDate: editVal}
                    ]);
                    $(".dp-selected",this['$'+this.view.toLowerCase()]).removeClass("dp-selected");
                    $(evnt.target).addClass("dp-selected");
                    break;
                case "year":
                    this.currentMonth = val;
                    break;
                case "yearset":
                    this.currentYear = val;
                    break;
            }
            this._layout(nextView);
            //manually focus on the field if clicked on the popup buttons for non-touch device
            if(!this.touchSupported) {
                //No need to focus if selection is made by pressing space.
                if(!this.hotKeyPressed) {
                    this.scriptFocus = true;
                    if(nextView == null) {
                        this.focusedOnDatepickerItem = false;
                    }
                }
            } else if(nextView == null){
                //For touch devices, deactivate the field if a selection is made
                this.focusedOnDatepickerItem = false;
                this._deactivateField()
            }
        },

        _leapYear : function() {
            return this.currentYear % 400 == 0 || (this.currentYear % 100 != 0 && this.currentYear % 4 == 0);
        },

        _maxDate : function(m) {
            if(this._leapYear() && m == 1)
                return 29;
            else return dates[m];
        },

        _access: function(val) {
            if(typeof val == "undefined")
                return this.access
            this.access = val;
        },

        _value:function(val) {
            if(typeof val == "undefined")
                return this.$field.val()
            else {
                this.selectedDate = val;
                var editValue = this.editValue(val);
                // update the field val with provided value instead of null
                if (!editValue) {
                    editValue = val;
                }
                this.$field.val(editValue);
            }
        }
    });

    var adobeDateTimePicker = new DateTimePicker();

    $.fn.adobeDateTimePicker = function(options, value) {
        if(!adobeDateTimePicker.initialized) {
            adobeDateTimePicker.create(options);
            adobeDateTimePicker.initialized = true;
        }
        if(typeof options === "object") {
            adobeDateTimePicker._attachField(this, options);
        }
        else if(typeof options === "string") {
            if(arguments.length == 2)
                adobeDateTimePicker["_"+options].apply(xfaUtil.$data(this[0],"datetimepicker"),[value])
            else
                return adobeDateTimePicker["_"+options].apply(xfaUtil.$data(this[0],"datetimepicker"))
        }
        return this;
    }
})(_, $, xfalib);
(function (xfalib) {
    xfalib.ut.TouchUtil = (function () {
        var touchAvailable = !!("ontouchstart" in window || window.DocumentTouch && document instanceof DocumentTouch) ,
            pointerEnabled = !!(window.MSPointerEvent || window.PointerEvent) ,
            POINTER_DOWN_EVENT = "mousedown",
            POINTER_MOVE_EVENT = "mousemove",
            POINTER_UP_EVENT = "mouseup",
            EVENT_TYPE = "MouseEvent";

        if (window.PointerEvent) { //> IE11
            POINTER_DOWN_EVENT = "pointerdown";
            POINTER_MOVE_EVENT = "pointermove";
            POINTER_UP_EVENT = "pointerup";
            EVENT_TYPE = "PointerEvent";

        } else if (window.MSPointerEvent) { // IE10
            POINTER_DOWN_EVENT = "MSPointerDown";
            POINTER_MOVE_EVENT = "MSPointerMove";
            POINTER_UP_EVENT = "MSPointerUp";
            EVENT_TYPE = "MSPointerEvent" ;

        } else if (touchAvailable) {  // other touch devices
            POINTER_DOWN_EVENT = "touchstart";
            POINTER_MOVE_EVENT = "touchmove";
            POINTER_UP_EVENT = "touchend";
            EVENT_TYPE = "TouchEvent";
        }
        return {
            TOUCH_ENABLED: touchAvailable,
            // new MS Pointer Events
            POINTER_EVENT: EVENT_TYPE,
            POINTER_ENABLED: pointerEnabled,
            POINTER_DOWN: POINTER_DOWN_EVENT,
            POINTER_MOVE: POINTER_MOVE_EVENT,
            POINTER_UP: POINTER_UP_EVENT,
            getTouchEvent: function (evt) {
                var target;
                if (pointerEnabled) {
                    target = evt.originalEvent;
                } else if (touchAvailable) {
                    target = evt.originalEvent || evt;
                    target = target.touches[0];
                    //if (evt.originalEvent && evt.originalEvent.changedTouches && evt.originalEvent.changedTouches[0]) {
                    //    te = evt.originalEvent.changedTouches[0];
                    //}
                }

                return target || evt;
            },
            getPointerEvent: function (eventType) {
                var event = null;
                if ((typeof PointerEvent) === "function") {
                    event = new PointerEvent(eventType, {
                        bubbles: true,
                        cancelable: true
                    });
                } else {
                    event = document.createEvent(EVENT_TYPE);
                    event.initEvent(eventType, true, true);
                }
                return event;
            },
            getTouches:function(evt){
                var touches = [];
                if(touchAvailable && evt.originalEvent && evt.originalEvent.touches ){
                    touches = evt.originalEvent.touches;
                }
                return touches;
            }
        };
    })();
})(xfalib);
(function ($, _) {
    $.widget("xfaWidget.abstractWidget", {

        $userControl: null,

        $data: xfalib.ut.XfaUtil.prototype.$data,

        $css: xfalib.ut.XfaUtil.prototype.$css,

        getOrElse: xfalib.ut.Class.prototype.getOrElse,

        dIndexOf: xfalib.ut.XfaUtil.prototype.dIndexOf,

        btwn: xfalib.ut.XfaUtil.prototype.btwn,

        logger: xfalib.ut.XfaUtil.prototype.getLogger,

        localeStrings: xfalib.ut.XfaUtil.prototype.getLocaleStrings,

        logMsgs: xfalib.ut.XfaUtil.prototype.getLogMessages,

        errorManager: xfalib.ut.XfaUtil.prototype.getErrorManager,

        _widgetName: "abstractWidget",

        // if there are any specific black listed attributes, each widget should define their own
        _blackListedAttributes : ["type"],

        options: {
            name: "",
            value: null,
            commitProperty: "value",
            displayValue: null,
            screenReaderText: null,
            tabIndex: 0,
            role: null,
            paraStyles: null,
            dir: null,
            errorMessage: null,
            warningMessage: null,
            hScrollDisabled: false,
            placeholder:"",
            isValid:true,
            mandatory: false
        },

        getOptionsMap: function () {
            return {
                "tabIndex": function (val) {
                    this.$userControl.attr("tabindex", val);
                },
                "role": function (val) {
                    if (val)
                        this.$userControl.attr("role", val);
                },
                "screenReaderText": function (val) {
                    if (val)
                        this.$userControl.attr("aria-label", val)
                },
                "paraStyles": function (val) {
                    if (val)
                        this.$css(this.$userControl.get(0), val);
                },
                "dir": function (val) {
                    if (val)
                        this.$userControl.attr("dir", this.options.dir);
                },
                "height": function (val) {
                    if (val) {
                        this.$css(this.$userControl[0], {"height": val})
                    }
                },
                "width": function (val) {
                    if (val)
                        this.$css(this.$userControl[0], {"width": val})
                },
                "isValid": function (val) {
                    if(val){
                      this.$userControl.removeAttr("aria-invalid");
                    } else {
                      this.$userControl.attr("aria-invalid",true);
                    }
                },
                "color" : function(value) {
                    if(!_.isEmpty(value)) {
                        var color = "rgb(" + value + ")";
                        this.$css(this.$userControl[0], {"color": color});
                    }
                },
                "font-style" : function (value) {
                    if (!_.isEmpty(value)) {
                        this.$css(this.$userControl[0], {"font-style": value});
                    }
                },
                "mandatory" : function (value) {
                    if(value){
                        this.$userControl.attr("aria-required", true);
                    } else {
                        this.$userControl.removeAttr("aria-required");
                    }
                }
            };
        },

        getEventMap: function () {
            return {
                "focus": xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
                "blur": xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                "click": xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT
            };
        },

        /**
         * Copies all the attributes from source jquery object to destination jquery object
         * @param $src      source jquery object
         * @param $dest     destination jquery object
         */
        copyAttributesFromSrcToDest : function($src, $dest){
            var that = this;
            // let's get all the attribute from the src element and copy it to dest jquery object
            if($src != null && $src[0] && $src[0].attributes && $dest != null){
                $.each($src[0].attributes, function() {
                    // we don't add the black listed set of attributes
                    if(this.specified && this.value != null && _.isString(this.value) && this.value.length > 0 && that._blackListedAttributes.indexOf(this.name) === -1) {
                        $dest.attr(this.name, this.value);
                    }
                });
            }
        },

        _create: function () {
            this.widgetEventPrefix = "";
            this.element.addClass(this._widgetName);
            this.$userControl = this.render();
            this.optionsHandler = this.getOptionsMap();
            this.eventMap = this.getEventMap();
            this._initializeOptions();
            this._initializeEventHandlers();
            this.errObj = this.errorManager();
            //call it only after render
            // Dirty hack to prevent this being called in Guide
            if (typeof guidelib === "undefined") {
                this.$css(this.$userControl.get(0), {
                    "box-sizing": "border-box",
                    "position": "absolute"
                });
            }
        },

        _initializeEventHandlers: function () {
            xfalib.ut.XfaUtil.prototype.getLogger().debug("xfa", "initialize event handlers for " + this._widgetName);
            _.each(this.eventMap, function (xfaevent, htmlevent) {
                var self = this;
                if (xfaevent) {
                    if (!(xfaevent instanceof  Array)) {
                        xfaevent = [xfaevent];
                    }
                    for (var i = 0; i < xfaevent.length; i++) {
                        xfalib.ut.XfaUtil.prototype.getLogger().debug("xfa", "binding " + htmlevent + " with " + xfaevent[i]);
                        this.$userControl.on(htmlevent,
                            (function (xfevnt) {
                                return function (evnt) {
                                    xfalib.ut.XfaUtil.prototype.getLogger().debug("xfa", "trigger " + evnt.type +
                                    " xfa-event " + xfevnt);
                                    self._preProcessEvent.apply(self, [xfevnt, evnt]);
                                    //since the fix https://github.com/jquery/jquery/pull/972, Fix for keeping namespace when triggering an event using an Event #972
                                    //we need to clear the namespace and its regular expression of triggering event, as the listeners are registered on un-namespaced events
                                    evnt.namespace = "";
                                    evnt.namespace_re = "";
                                    self._trigger(xfevnt, evnt);
                                    self._postProcessEvent.apply(self, [xfevnt, evnt]);
                                }
                            })(xfaevent[i])
                        )

                    }
                }
            }, this)
        },

        _preProcessEvent: function (xfaevent, htmlevent) {
            if (xfaevent == this.options.commitEvent) {
                this.preProcessCommit(htmlevent);
            }
            switch (xfaevent) {
                case xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT:
                    this.preProcessEnter(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT:
                    this.preProcessExit(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT:
                    this.preProcessChange(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT:
                    this.preProcessClick(htmlevent);
                    break;
            }

        },

        _postProcessEvent: function (xfaevent, htmlevent) {
            if (xfaevent == this.options.commitEvent) {
                this.postProcessCommit(htmlevent);
            }
            switch (xfaevent) {
                case xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT:
                    this.postProcessEnter(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT:
                    this.postProcessExit(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT:
                    this.postProcessChange(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT:
                    this.postProcessClick(htmlevent);
                    break;
            }
        },

        _initializeOptions: function () {
            _.each(this.optionsHandler, function (value, key) {
                if (typeof value === "function")
                    value.apply(this, [this.options[key]]); // TODO: check whether it is needed for initialization or not
            }, this)
        },

        _setOption: function (key, value) {
            if (this.options[key] != value) {
                this.options[ key ] = value;
                if (typeof this.optionsHandler[key] === "function") {
                    this.optionsHandler[key].apply(this, [this.options[key]])
                }
            }
        },

        /**
         * @override
         */
        option: function (key, value) {
            if (arguments.length === 1 &&
                typeof key === "string" &&
                this.options.hasOwnProperty(key) &&
                this.options[key] === undefined) {
                return undefined;
            }
            return $.Widget.prototype.option.apply(this, arguments)
        },

        destroy: function () {
            this.$userControl.removeClass(this._widgetName);
        },


        render: function () {
            var control;
            if (this.element.children().length > 0) {
                control = $(this.element.children().get(0));
            }
            else
                control = this.element;
            control.attr("name", this.options.name)
            return control;
        },


        preProcessCommit: function (evnt) {
            this.options.value = this.getCommitValue();
            xfalib.ut.XfaUtil.prototype.getLogger().debug("xfa", "passing commit value " + this.options.value +
            "to model ");
        },

        getCommitValue: function () {

        },

        preProcessExit: function (evnt) {

        },

        preProcessEnter: function (evnt) {
            //Only focus the enabled widgets
            if (this.options.access === "open") {
                this._showError();
                this.showValue();
            }
        },

        preProcessChange: function (evnt) {

        },

        preProcessClick: function (evnt) {

        },

        postProcessCommit: function (evnt) {
            this.showDisplayValue();
        },

        postProcessExit: function (evnt) {
            //Only for the enabled widgets
            if (this.options.access === "open") {
                this.showDisplayValue();
                this._hideError();
            }
        },

        postProcessEnter: function (evnt) {
        },

        postProcessChange: function (evnt) {

        },

        postProcessClick: function (evnt) {

        },

        showDisplayValue: function () {
            this.$userControl.val(this.options.displayValue)
        },

        /**
         * Checks if the edit value is same as value present in the user control(html form element)
         * @returns {boolean}
         */
        _isValueSame : function(){
            return (((this.options.value === null) && (this.$userControl.val() === "")) || (this.options.value === this.$userControl.val()));
        },

        showValue: function () {
            // May be $userControl doesn't have val(), using it as of now
            // If the value of the field is not same as edit value, only then set the value, this also solves IE bug of cursor
            // moving to the end of field on click
            if(!this._isValueSame()) {
                this.$userControl.val(this.options.value)
            }
        },

        focus: function () {
            var that = this;
            // setTimeout added to fix CQ-51141
            // While using setFocus API in adaptive form, the focus was not being set in TextBox on chrome
            // and also on click of caption of RadioButton/Checkbox, due to fast event execution, hence adding delay during focus.
            setTimeout(function(){
                that.$userControl[0].focus();
            }, 1);
        },

        click: function () {
            this.focus();
            this.$userControl.triggerHandler("click"); // we do not want the exact click as might bubble up to the field.
        },

        /* widget specific code */

        _showError: function () {
            if(this.errObj && _.isFunction(this.errObj.onFieldEnter)) {
                this.errObj.onFieldEnter(this);
            }
        },

        _calculatePaddingForVAlign:function(diff){
           var flagForMoz = $.browser.mozilla && !xfalib.ut.Utilities.isIE11() &&
                              this.options.multiLine,
               vAlignBottomOrTop = this.options.paraStyles &&
                                   (this.options.paraStyles["vertical-align"] == "bottom" ||
                                    this.options.paraStyles["vertical-align"] == "top");

           if(flagForMoz && vAlignBottomOrTop || $.browser.msie && this.options.multiLine) {
              return;
           }
           // to handle the edge cases, if the diff is like -0.01 the whole operation is getting aborted
           // this diff comes mainly due to scroll height getting rounded off when widgetHeight is like x.999999
           diff = (diff > -0.01) ? Math.abs(diff) : diff;
           if (this.options.paraStyles && diff > 0) {
                var vAlign = this.options.paraStyles["vertical-align"];
                if (vAlign == "bottom") {
                    diff = diff - this.options.paraStyles["padding-bottom"];
                    this.$userControl.css("padding-top", diff);
                    this.padding = this.$userControl.css("padding-top");
                }
                else if (vAlign == "top" || (vAlign != "middle" && vAlign == undefined)) {
                    if (this.options.paraStyles["padding-top"])
                        diff = diff - this.options.paraStyles["padding-top"];
                    this.$userControl.css("padding-bottom", diff);
                    this.padding = this.$userControl.css("padding-bottom");
                }
                else if (this.options.multiLine && vAlign == "middle") {
                    var newDiff = diff / 2;
                    newDiff = newDiff - this.options.paraStyles["padding-bottom"];
                    if (this.options.paraStyles["padding-top"])
                        newDiff = newDiff + this.options.paraStyles["padding-top"];
                    this.$userControl.css("padding-top", newDiff);
                }
            }
        },

        _handleVAlignOnExit: function (evnt) {

            if (!this.options.paraStyles) {
                //vAlign has to be handled only if there is paraStyles
                return;
            }
            var value = this.options.displayValue,
                lineHeight = xfalib.view.util.TextMetrics.measureExtent(value, {refEl: this.$userControl.get(0), maxHeight: -1}).height,
                widgetHeight = this.options.height,
                diff = widgetHeight - lineHeight;
            this._calculatePaddingForVAlign(diff);

        },

        _handleVAlignOnEnter: function (evnt) {
            //Only align the enabled widgets
            var flagForIE = $.browser.msie && this.options.multiLine;
            if (this.options.paraStyles && !flagForIE) {
                 var vAlign = this.options.paraStyles["vertical-align"];
                 if (vAlign == "bottom" && this.padding)
                     this.$userControl.css("padding-top", this.padding);
                 else if (vAlign == "top" && this.padding)
                     this.$userControl.css("padding-bottom", this.padding);
            }
        },

        _hideError: function () {
            if(this.errObj && _.isFunction(this.errObj.onFieldExit)) {
                this.errObj.onFieldExit(this);
            }
        },

        markError: function (msg, type) {
            if(this.errObj && _.isFunction(this.errObj.markError)) {
                this.errObj.markError(this, msg, type);
            }
        },

        clearError: function () {
            if(this.errObj && _.isFunction(this.errObj.clearError)) {
                this.errObj.clearError(this);
            }
        },

        getEditValue: function(value) {
            if(this.options.editPattern == null) {
                return value;
            }
            try {
                return xfalib.ut.PictureFmt.format(value, this.options.editPattern);
            } catch(e) {
                return null;
            }
        },

        parseEditValue: function(value) {
            if(this.options.editPattern == null) {
                return value;
            }
            try {
                return xfalib.ut.PictureFmt.parse(value, this.options.editPattern);
            } catch(e) {
                return value;
            }
        }
    });
})($, window._);
(function($) {
    $.widget( "xfaWidget.defaultWidget", $.xfaWidget.abstractWidget, {

        _widgetName: "defaultWidget",

        getOptionsMap: function() {
            var parentOptionsMap = $.xfaWidget.abstractWidget.prototype.getOptionsMap.apply(this,arguments);
            return $.extend({},parentOptionsMap,{
                "access": function(val) {
                    switch(val) {
                        case "open" :
                            this.$userControl.removeAttr("readOnly");
                            this.$userControl.removeAttr("aria-readonly");
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                        case "nonInteractive" :
                        case "protected" :
                            this.$userControl.attr("disabled", "disabled");
                            this.$userControl.attr("aria-disabled", "true");
                            break;
                        case "readOnly" :
                            this.$userControl.attr("readOnly", "readOnly");
                            this.$userControl.attr("aria-readonly", "true");
                            break;
                        default  :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                    }
                },

                "displayValue": function(val) {
                    if(this.options.commitProperty) {
                        if($.browser.mozilla && this.options.commitProperty == "value") {
                            // on submitting form firefox does not remember autocomplete values, if updated through attr()
                            this.$userControl.val(this._displayEmptyStringForIE(this.options.displayValue));
                        } else {
                            this.$userControl.prop(this.options.commitProperty, this._displayEmptyStringForIE(this.options.displayValue));
                            this.$userControl.attr(this.options.commitProperty, this._displayEmptyStringForIE(this.options.displayValue));
                        }
                    } else {
                        this.logger().debug("xfaView", "[DefaultWidget._update], User Control or Commit Property is null");
                    }
                },

                "placeholder": function(value){
                    this.$userControl.attr("placeholder", value);
                }
            });
        },

        _displayEmptyStringForIE: function(value){
            /*CQ-69417: By default "null" is displayed in the comments text box
              "null" values shown in IE */
            // CQ-69107 included check for edge as well
            return (value == null && xfalib.ut.XfaUtil.prototype.detectIE()) ? '' : value;
        },

        render : function() {
            var control = $.xfaWidget.abstractWidget.prototype.render.apply(this,arguments)
            this._attachEventHandlers(control)
            return control
        },

        getCommitValue: function() {
            var value = this.$userControl.val();
            if(this.options.hScrollDisabled && !this.options.multiLine)
                var value = xfalib.ut.XfaUtil.prototype.splitStringByWidth(this.$userControl.val(),this.$userControl.width(),this.$userControl.get(0)) ;
            return value;
        },

        _attachEventHandlers: function($control) {
            $control.keydown($.proxy(this._handleKeyDown,this));
            $control.keypress($.proxy(this._handleKeyPress,this));
            $control.on('paste',$.proxy(this._handlePaste,this));
            $control.on('cut',$.proxy(this._handleCut,this));
        },

        _compositionUpdateCallback : function (event) {
            return false;
        },

        _attachCompositionEventHandlers : function($control) {
            var isComposing = false; // IME Composing going on
            var hasCompositionJustEnded = false; // Used to swallow keyup event related to compositionend
            // IME specific handling, to handle japanese languages max limit
            // since enter can also be invoked during composing, a special handling is done here
            var that = this,
                changeCaratPosition = function() {
                    // change the carat selection position to further limit input of characters
                    var range = window.getSelection();
                    range.selectAllChildren(that.$userControl[0]);
                    range.collapseToEnd();
                };
            $control.keyup(function(event) {
                if (/*isComposing || */hasCompositionJustEnded) {
                    if (that._compositionUpdateCallback(event)) {
                        changeCaratPosition();
                    }
                    // IME composing fires keydown/keyup events
                    hasCompositionJustEnded = false;
                }
            });
            $control.on("compositionstart",
                function(event) {
                    isComposing = true;
                })
                .on("compositionupdate",
                    function(event) {
                        // event.originalEvent.data refers to the actual content
                        if (that._compositionUpdateCallback(event)) {
                            changeCaratPosition();
                        }
                    })
                .on("compositionend",
                    function(event) {
                        isComposing = false;
                        // some browsers (IE, Firefox, Safari) send a keyup event after
                        //  compositionend, some (Chrome, Edge) don't. This is to swallow
                        // the next keyup event, unless a keydown event happens first
                        hasCompositionJustEnded = true;
                    })
                .on("keydown",
                    function(event) {
                        // Safari on OS X may send a keydown of 229 after compositionend
                        if (event.which !== 229) {
                            hasCompositionJustEnded = false;
                        }
                    });
        },

        _handleKeyDown : function(event){
            if(event.keyCode == 13 || event.charCode == 13 || event.which == 13) // touch devices may return charCode
                event.preventDefault();
        },

        _handleKeyPress : function(event){
            if(event.keyCode == 13 || event.charCode == 13 || event.which == 13) // touch devices may return charCode
                event.preventDefault();
        }
    });
})($);
(function($, _) {
    var xfaUtil = xfalib.ut.XfaUtil.prototype;
    $.widget( "xfaWidget.dateTimeEdit", $.xfaWidget.defaultWidget, {

        _widgetName : "dateTimeEdit",

        getEventMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
            if(this._nativeWidget === false) {
                return $.extend({}, parentOptionsMap, {
                    "onfocus1.datetimepicker": xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
                    "onvaluechange.datetimepicker": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    "onfocusout.datetimepicker": xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    "onoverlap.datetimepicker": xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT, // Custom Event to fix BUG #3626974
                    "input": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT, // TODO : add handler for xfa.event.change
                    "focus": null,
                    "blur": null
                })
            } else {
                return $.extend({}, parentOptionsMap, {
                    "change": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
                })
            }
        },

        _getAdobeDatePickerOptionsMap : function(parentOptionsMap) {
            return {
                "access" : function (val) {
                    switch (val) {
                        case "open" :
                            this.$userControl.adobeDateTimePicker("access", true);
                            break;
                        case "nonInteractive" :
                        case "protected" :
                        case "readOnly" :
                            this.$userControl.adobeDateTimePicker("access", false);
                            break;
                    }
                    parentOptionsMap.access.apply(this, arguments);
                },
                "displayValue" : function (val) {
                    // set the value in the datepicker plugin
                    this.$userControl.adobeDateTimePicker("value", this.options.value);
                    // show the display value
                    this.showDisplayValue();
                }
            }
        },

        _getNativeDatePickerOptionsMap: function (parentOptionsMap) {
            return {
                "displayValue": function (val) {
                    this.showDisplayValue();
                }
            }
        },


        getOptionsMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments),
                datePickerOptions = this._nativeWidget === false ? this._getAdobeDatePickerOptionsMap(parentOptionsMap)
                    : this._getNativeDatePickerOptionsMap(parentOptionsMap),
                commonOptions = {
                    "paraStyles": function (paraStyles) {
                        parentOptionsMap.paraStyles.apply(this, arguments);
                        this._handleVAlignOnExit();
                    },

                     "access": function(val) {
                        // update width on change of access (as width of widget is dependent on access)
                        // The calender icon should be hidden, and widget should take full space when readOnly
                        parentOptionsMap.access.apply(this, arguments);
                        this.getOptionsMap().width.apply(this,[this.options.width]);
                      },
                     "width": function (val) {
                        parentOptionsMap.width.apply(this, arguments);
                        if (this.options.showCalendarIcon && val && this.options.access == "open") {
                            var effectiveWidth = val > this.options.calendarIconWidth ? val - this.options.calendarIconWidth : val;
                            this.$userControl.width(effectiveWidth);  // leave space for the cal icon
                        }
                    },

                    "height": function(val) {
                        parentOptionsMap.height.apply(this, arguments);
                        this._handleVAlignOnExit();
                    },
                    "screenReaderText": function (val) {
                        var editPattern = this.options.editPattern;
                        var defaultEditPattern = this._nativeWidget ? "mm/dd/yyyy" : "YYYY-MM-DD";
                        var regex = /(?:date){0,1}{(.*)}/; // date{<pattern>} or {<pattern>} both are valid as per xfa spec
                        editPattern = typeof editPattern === "string" ? editPattern.match(regex)[1] : defaultEditPattern;
                        var defaultLabel = "Please Enter date in {0} format only";
                        if (editPattern) {
                            var ariaLabel = xfalib.ut.LocalizationUtil.prototype.getLocalizedMessage("",
                                xfalib.locale.Strings.datePickerAriaLabel || defaultLabel, [editPattern])
                        }
                        var finalVal = val !== undefined ? val + " " + ariaLabel : val;
                        this.$userControl.attr("aria-label", finalVal);
                    }
                };
            return $.extend({},parentOptionsMap,datePickerOptions, commonOptions);
        },

        postProcessExit: function(evnt) {
            $.xfaWidget.defaultWidget.prototype.postProcessExit.apply(this,arguments);
            this._handleVAlignOnExit ();
        },

        preProcessEnter: function(evnt) {
            $.xfaWidget.defaultWidget.prototype.preProcessEnter.apply(this,arguments);
            this._handleVAlignOnEnter();
        },

        preProcessChange: function(evnt) {
           //CQ-46332:loss of date value in date-picker , setting the value here or else
           //it gets lost during focus
           if(this._nativeWidget === true){
            this.options.value = this.$userControl.val();
           }
        },

        showDisplayValue: function() {
            if(this._nativeWidget === false) {
                $.xfaWidget.defaultWidget.prototype.showDisplayValue.apply(this, arguments);
            } else {
                this.showValue();
            }
        },


        showValue: function () {
            if (this._nativeWidget == false) {
                this.$userControl.adobeDateTimePicker("value", this.options.value);
            } else {
                $.xfaWidget.defaultWidget.prototype.showValue.apply(this, arguments);
            }
            $.xfaWidget.textField.prototype._selectOnFocusInIE.apply(this, arguments);
        },

        getCommitValue: function() {
            if (this._nativeWidget === false) {
                var value = this.$userControl.adobeDateTimePicker("value"),
                    parsedValue = this.parseEditValue(value);
                return parsedValue;
            }
            return $.xfaWidget.defaultWidget.prototype.getCommitValue.apply(this, arguments);
        },

        render: function() {
            var self = this,
                textStyle = this.getOrElse(this.$data(this.element.get(0), "xfamodel"), "textstyle", ""),
                $control = $.xfaWidget.abstractWidget.prototype.render.apply(this, arguments),
                $source = $control,
                id,
                existingInlineStyleAttributeValues,
                newInlineStyleAttributeValues,
                combinedInlineStyleAttributeValues;
            existingInlineStyleAttributeValues = this.element.find("input").attr("style") || '';
            this._nativeWidget = true;
            if(this.options.useNativeWidget === false || $control[0].type !== "date") {
                this._nativeWidget = false;
                id = this.element.find("input")[0].id;
                this.element.children().remove();
                $("<div></div>").css({position: "relative", width: "100%", height: "100%"}) // want to fill entire width of containing table cell
                    .append($("<input type='text'/>"))
                    .appendTo(this.element);
                $control = $("input", this.element).
                    attr("style", textStyle).
                    attr("name", this.options.name).
                    attr("id", id).
                    adobeDateTimePicker({
                        positioning: this.element,
                        locale: {
                            months: this.options.months,
                            days: this.options.days,
                            zero: this.options.zero,
                            clearText: this.options.clearText
                        },
                        access: this.options.access,
                        value: this.options.value,
                        showCalendarIcon: this.options.showCalendarIcon,
                        iconWidth: this.options.calendarIconWidth,
                        minValidDate : this.options.minValidDate,
                        maxValidDate : this.options.maxValidDate,
                        exclMinDate :  this.options.exclMinDate,
                        exclMaxDate : this.options.exclMaxDate,
                        editValue: function (value) {
                            return self.getEditValue(value);
                        }
                    });
            }
            this._attachEventHandlers($control);
            newInlineStyleAttributeValues = this.element.find("input").attr("style") || '';
            //append the previous inlineStyleAttributeValues to newInlineStyleAttributeValues so that the inline styles
            //added from the dialog are applied.
            combinedInlineStyleAttributeValues = newInlineStyleAttributeValues + existingInlineStyleAttributeValues;
            this.element.find("input").attr("style", combinedInlineStyleAttributeValues);
            // only in case of adaptive form, we would copy the attributes back
            if(window.guideBridge) {
                // restore the original attribute back to destination object
                this.copyAttributesFromSrcToDest($source, this.element.find("input"));
            }
            return $control;
        }
    }) ;

})($, _);
(function($, _) {
$.widget("xfaWidget.numericInput", $.xfaWidget.defaultWidget, {

    _widgetName: "numericInput",

	options : {
		value : null,
		curValue: null,
        pos: 0,
        lengthLimitVisible: true,
        zero:"0",
        decimal:".",
        minus:"-"
	},

    //TODO: to support writing in different locales \d should be replaced by [0-9] for different locales
    _matchArray : {
                    "integer":"^[+-]?{digits}*$",
                    "decimal":"^[+-]?{digits}{leading}({decimal}{digits}{fraction})?$",
                    "float":"^[+-]?{digits}*({decimal}{digits}*)?$"
                  },

    _regex : null,

    _engRegex : null,

    _writtenInLocale : false,

    _previousCompositionVal : "",


    _toLatinForm : function (halfOrFullWidthStr) {
        // refer http://www.fileformat.info/info/unicode/block/halfwidth_and_fullwidth_forms/utf8test.htm
        return halfOrFullWidthStr.replace(
            /[\uff00-\uffef]/g,
            function(ch) { return String.fromCharCode(ch.charCodeAt(0) - 0xfee0); }
        );
    },

    getOptionsMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "paraStyles": function(paraStyles){
                parentOptionsMap.paraStyles.apply(this,arguments);
                this._handleVAlignOnExit ();
            } ,

            "height": function(val) {
                if(val)   {
                    this.$css(this.$userControl[0],{"height" :val});
                    this._handleVAlignOnExit();    // To Handle the case of expandable Fields
                }
            }

        })
    },

    getEventMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "onKeyInput.numericInput" : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
        })
    },

    _getDigits: function() {
        var zeroCode = this.options.zero.charCodeAt(0),
            digits = "";
        for(var i = 0;i < 10;i++) {
            digits += String.fromCharCode(zeroCode + i);
        }
        return "["+digits+"]"
    },

    _escape: function(str) {
      return str.replace(".","\\.")
    },

    postProcessExit: function(evnt) {
        $.xfaWidget.defaultWidget.prototype.postProcessExit.apply(this,arguments);
        this._handleVAlignOnExit ();
    },

    preProcessEnter: function(evnt) {
        $.xfaWidget.defaultWidget.prototype.preProcessEnter.apply(this,arguments);
        this._handleVAlignOnEnter();
    },

	render : function() {
        var matchStr =  this._matchArray[this.options.dataType];
        if(matchStr) {
            var ld = this.options.leadDigits,
                fd = this.options.fracDigits,
                ldstr = ld && ld != -1 ? "{0,"+ld+"}"
                    : "*",
                fdstr = fd && fd != -1 ? "{0,"+fd+"}"
                    : "*",
                matchStr =  matchStr.replace("{leading}",ldstr)
                                    .replace("{fraction}",fdstr),
                localeStr = matchStr.replace(/{digits}/g,this._getDigits())
                                    .replace("{decimal}",this._escape(this.options.decimal)),
                engStr = matchStr.replace(/{digits}/g,"[0-9]")
                                .replace("{decimal}","\\.")
            this._processValue = !(this._getDigits() == "[0123456789]" && this.options.decimal == ".")
            this._regex = new RegExp(localeStr, "g");
            this._engRegex = new RegExp(engStr, "g");
        }
        return $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
    },

    getCommitValue: function() {
        var value = $.xfaWidget.defaultWidget.prototype.getCommitValue.apply(this, arguments);
        // we support full width, half width and locale specific numbers
        value = this._toLatinForm(value);
        if(value.length > 0 && this._processValue && !value.match(this._engRegex)) {
            this._writtenInLocale = true;
            value = this._convertValueFromLocale(value);
        } else {
            this._writtenInLocale = false
        }
        if(value && value.length >= this.options.combCells )
            value = value.slice(0,this.options.combCells);
        this._previousCompositionVal = value;
        return value;
    },

    _compositionUpdateCallback : function (event) {
        var that = this;
        var flag = false;
        var leadDigits = that.options.leadDigits;
        var fracDigits = that.options.fracDigits;
        // we don't check use-case where just fracDigits is set since in case of composition update, the value to update is not known
        if (leadDigits !== -1) {
            var val = that.$userControl.val();
            if (event.type === "compositionupdate" && event.originalEvent.data) {
                val = val + event.originalEvent.data.substr(event.originalEvent.data.length - 1);
            }
            // can't use the existing regex (since current regex checks for english digits), rather doing leadDigit compare
            var totalLength = leadDigits + (fracDigits !== -1 ? (fracDigits + that.options.decimal.length) : 0);
            if (val.indexOf(that.options.decimal) === -1) {
                totalLength = leadDigits;
            }
            var latinVal = this._toLatinForm(val);
            // match both since we support full width, half width and locale specific input
            var match = latinVal.match(that._regex)|| latinVal.match(this._engRegex);
            flag  = !match;
            if (match === null) {
                // entered invalid character, revert to previous value
                that.$userControl.val(that._previousCompositionVal);
                flag = true;
            } else if (flag) {
                // if max reached
                var newVal = val.substr(0, totalLength);
                that.$userControl.val(newVal);
                that._previousCompositionVal = newVal;
                flag = true;
            } else {
                that._previousCompositionVal = val;
            }
        }
        return flag;
    },

    _attachEventHandlers : function($control) {
        $.xfaWidget.defaultWidget.prototype._attachEventHandlers.apply(this, arguments);
        // IME specific handling, to handle japanese languages max limit
        $.xfaWidget.defaultWidget.prototype._attachCompositionEventHandlers.apply(this, arguments);
	},

    _handleKeyInput : function(event, character, code){
        if(event.ctrlKey && !_.contains(['paste', 'cut'], event.type)) {
            return true;
        }

        $.xfaWidget.defaultWidget.prototype._handleKeyDown.apply(this,arguments);
        this.options.lengthLimitVisible = true;

        var val = this.$userControl.prop(this.options.commitProperty) || '',
            // if selectionStart attribute isn't supported then its value will be undefined
            selectionStart = xfalib.view.util.HtmlUtil.getHTMLSupportedAttr(this.$userControl[0], "selectionStart"),
            isSelectionAttrSupported = !(selectionStart === undefined || selectionStart === null),
            selectionStart = selectionStart || 0,
            selectionEnd = xfalib.view.util.HtmlUtil.getHTMLSupportedAttr(this.$userControl[0], "selectionEnd") || 0,
            combCells = parseInt(this.options.combCells) || 0,
            current,
            change = character;

        if (combCells > 0 ) {
            change = character.substr(0, combCells - val.length + selectionEnd - selectionStart);
        }

        current = val.substr(0, selectionStart) + change + val.substr(selectionEnd);
        // done to handle support for both full width, half width or mixed input in number field
        var latinCurrentValue = this._toLatinForm(current);

	// we want to check regex first and then see whether it was numeric or not.
        if (!(this._regex == null || latinCurrentValue.match(this._regex) || latinCurrentValue.match(this._engRegex))) {
            event.preventDefault();
            return false;
        }

	// CQ-4245407 : selectionStart and selectionEnd attributes aren't supported in case of input type = number
        // it is used for providing native HTML5 implementation for numeric field, so no further processing is required
        // As it is specific to AF and AF doesn't support change event on each keypress, so this change should be fine
        if (!isSelectionAttrSupported) {
            return true;
        }

        if (!_.contains(['keydown', 'cut'], event.type) && combCells && (val.length >= combCells || current.length > combCells) && selectionStart === selectionEnd) {
            event.preventDefault();
            return false;
        }

        this.options.curValue = val;
        this._previousCompositionVal = val;
        this.options.pos = selectionStart;

        if(this.options.hScrollDisabled && !_.contains(['keydown', 'cut'], event.type)) {
            var expectedWidth = xfalib.view.util.TextMetrics.measureExtent(current, {refEl: this.$userControl[0], maxWidth:-1}).width;
            if(!event.ctrlKey && expectedWidth > this.$userControl.width() - 5){
                event.preventDefault();
                this.options.lengthLimitVisible = false;
            }
        }

        this.$userControl.trigger({
            type : "onKeyInput.numericInput",
            originalType : event.type,
            character : character,  // contains the pasted string or pressed key
            keyCode : event.keyCode || 0,
            charCode : event.charCode || 0,
            which : event.which || 0,
            ctrlKey : event.ctrlKey || event.metaKey || false,
            shiftKey : event.shiftKey || false,
            keyDown : false, // This property is available only for list boxes and drop-down lists
            selectionStart: selectionStart,
            selectionEnd: selectionEnd
        });
    },

    _handleKeyDown : function(event){
        if (event) {
            var code = event.charCode || event.which || event.keyCode || 0;
            if(code == 8 || code == 46) // backspace and del
               this._handleKeyInput(event, "", code);
            else if(code == 32) { // suppress space
                event.preventDefault();
                return false;
            }
        }
    },

    _isValidChar: function (character) {
        character = this._toLatinForm(character);
        var lastSingleDigitChar = String.fromCharCode(this.options.zero.charCodeAt(0) + 9);
        // we only full width, half width and also locale specific if customer has overlayed the i18n file
        return (character >= "0" && character <= "9") || (character>=this.options.zero && character<=lastSingleDigitChar) || character===this.options.decimal || character===this.options.minus;
    },

    _handleKeyPress : function(event){
        if (event) {
            var code = event.charCode || event.which || event.keyCode || 0,
                character = String.fromCharCode(code);

            if(xfalib.ut.XfaUtil.prototype.isNonPrintableKey(event.key)) { // mozilla also generates a keypress, along with keydown
                return true;                                               // for all keys, so only handling printable keys in keypress
            }

            if (this._isValidChar(character))
                this._handleKeyInput(event, character, code);
            else if (!event.ctrlKey){
                event.preventDefault();
                return false;
            }
        }
    },

    _handlePaste : function(event){
        if (event) {
            var pastedChar = undefined;
            if (window.clipboardData && window.clipboardData.getData) { // IE
                pastedChar = window.clipboardData.getData('Text');
            } else if (event.originalEvent.clipboardData && event.originalEvent.clipboardData.getData) {
                pastedChar = event.originalEvent.clipboardData.getData('text/plain');
            }

            if(pastedChar) {
                var allPastedCharsValid = _.every(pastedChar.split(''), function (character) {
                    return this._isValidChar(character);
                }, this);
                if (allPastedCharsValid) {
                    // during paste we support both half width, full width and locale specific numbers
                    pastedChar = this._toLatinForm(pastedChar);
                    this._handleKeyInput(event, pastedChar, 0);
                }
                else if (!event.ctrlKey) {
                    event.preventDefault();
                    return false;
                }
            }
        }
    },

    _handleCut : function(event) {
        if (event) {
            this._handleKeyInput(event, "", 0);
        }
    },
    // CQ-107886 : added handling for negative values, as for '-', '-3' was getting returned
    _convertValueToLocale: function(val) {
        var zeroCode = this.options.zero.charCodeAt(0);
        return  _.map(val,function(c) {
            if(c == ".") {
                return this.options.decimal;
            } else if(c == "-") {
                return this.options.minus;
            } else {
                return String.fromCharCode(parseInt(c) + zeroCode);
            }
        },this).join("");
    },

    _convertValueFromLocale: function(val) {
        val = this._toLatinForm(val);
        var zeroCode = this.options.zero.charCodeAt(0);
        return  _.map(val,function(c) {
            if(c == this.options.decimal) {
                return ".";
            } else if(c == this.options.minus) {
                return "-";
            } else {
                return (c.charCodeAt(0) - zeroCode).toString();
            }
        },this).join("");
    },

    showValue : function() {
       // if the value is same, don't do anything
       if(!this._isValueSame()){
           if(this.options.value && this._writtenInLocale) {
               this.$userControl.val(this._convertValueToLocale(this.options.value))
           } else {
               this.$userControl.val(this.options.value)
           }
       }
       //IE doesn't show selected text if we focus and set its value all the time so force selection
       $.xfaWidget.textField.prototype._selectOnFocusInIE.apply(this, arguments);
    }
});
})($, window._);(function ($, _) {
    $.widget("xfaWidget.dropDownList", $.xfaWidget.defaultWidget, {            //commitEvent: change; commitProperty: value<Array>

        _widgetName: "dropDownList",

        options: {
            value: [],
            items: [],
            editable: false,
            placeholder: "",
            displayValue: []
        },

        widgetSkeleton: '<select name="" style="" size = "1"></select>',
        optionSkeleton: '<option data-user-option></option>',
        optGroupSkeleton: '<optgroup label=""></optgroup>',
        AF_OPTGROUP_NAME: "afOptGroupName",
        PLACE_HOLDER_STYLE_CLASS : "placeHolder",

        getOptionsMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "value": function (val) {
                    if (!_.isArray(val)) {
                        val = [val];
                    }
                    var selectedOptionFound = false,
                        that = this;
                    //sync option selection as per new values
                    $("option", this.$userControl).each(function (index) {
                        var selectValue = $(this).val();
                        //Check if this value is present in options value array
                        if (_.contains(val, selectValue)) {
                            $(this).prop("selected", true);
                            selectedOptionFound = true;
                        } else {
                            $(this).prop("selected", false);
                            if (this.id === "emptyValue") {
                                $(this).val("").html(that.options.placeholder);
                                //Hiding emptyValue with no placeholder text configured.
                                if(that.options.placeholder.length == 0) {
                                    $(this).hide();
                                }
                            }
                        }
                    });

                    /* Add default option if :
                    / 1. If placeholder add an extra option
                    / 2. If the value is set anything other than the options (and null/"") create a new option
                     */
                    if ((!selectedOptionFound && val.length != 0 && val[0] != null) || that.options.placeholder.length != 0) {
                        if (this.$userControl.children('[data-empty-option]').length == 0) {
                            var extraOption = document.createElement("option");
                            extraOption.setAttribute("data-empty-option", "");
                            extraOption.setAttribute("role", "none");
                            extraOption.setAttribute("value", "")
                            this.$userControl[0].insertBefore(extraOption, this.$userControl[0].firstChild);
                        }
                        // If placeholder is present the set value of empty option to placeholder
                        if (that.options.placeholder.length != 0) {
                            this.$userControl.children('[data-empty-option]').text(that.options.placeholder);
                        }
                        // If placeholder is present and value is not present then select placeholder
                        if (val.length == 0 || val[0] == null) {
                            this.$userControl.children('[data-empty-option]').prop("selected", true);
                        } // If value is set anything other than option then set empty option to value
                        else if (!selectedOptionFound && val.length != 0 && val[0] != null) {
                            this.$userControl.children('[data-empty-option]').text(val[0]).
                            prop("selected", true).
                            val(_.escape(val[0])).
                            show();
                        }

                    }
                    else if (that.options.placeholder.length == 0) {
                        // Delete default option if value is found in options while adding options
                        if (selectedOptionFound && this.$userControl.children('[data-empty-option]').val() != that.options.displayValue) {
                            if (this.$userControl.children('[data-empty-option]').length > 0) {
                                this.$userControl[0].removeChild(this.$userControl.children('[data-empty-option]')[0]);
                            }
                        }
                        // Reset the value of dropdown based on rule
                        else if (!selectedOptionFound && (val.length == 0 || val == null || val[0] == null)) {
                            this.$userControl[0].value = "";
                        }
                    }
                    this.$userControl.toggleClass(this.PLACE_HOLDER_STYLE_CLASS, val.length == 0 || val == null);
                },

                "items": function (val) {
                    if (!_.isArray(val)) {
                        val = [val];
                    }

                    var AF_OPTGROUP_NAME = "afOptGroupName";
                    var i, j, optgroupOptions = [], element, $viewOptgroup, $preOptgroup;
                    var viewOptgroups = $("optgroup", this.$userControl);
                    // Removes all options which earlier didn't belong to any optgroup.
                    if (viewOptgroups.length == 0) {
                        // save selected value because when value is set before items in setWidgetOptions
                        // the selected value would get lost in html
                        var selectedOption = this.$userControl.find('[selected]');
                        this.$userControl.children("option[data-user-option]").remove();
                    }
                    for (i = 0, j = 0; j < val.length; j++) {
                        element = val[j];
                        if (element.save != AF_OPTGROUP_NAME) {
                            // Add options to String[] which will be later synced to the optgroup.
                            optgroupOptions.push(element);
                        } else {
                            $viewOptgroup = viewOptgroups[i++];
                            // When optgroup is less than the required optgroups.
                            if (i > viewOptgroups.length) {
                                $viewOptgroup = this.addGroup(element.display);
                            }
                            // Undefined as it may not occur even once when list is purely of options.
                            if (!_.isUndefined($viewOptgroup) && $viewOptgroup.label != element.display) {
                                $viewOptgroup.label = element.display || '';
                            }
                            // Check to skip the first optgroup.
                            if (j != 0) {
                                // Syncs options to the prev optgroup.
                                // Prev optgroup because current optgroup marks the end of options of prev.
                                this.handleOptions($preOptgroup, optgroupOptions);
                                // Clear options of the optgroup for next optgroup.
                                optgroupOptions = [];
                            }
                            $preOptgroup = $viewOptgroup;
                        }
                    }
                    // Removes all extra optgroups.
                    while (i < viewOptgroups.length) {
                        $viewOptgroup = viewOptgroups[i++];
                        this.deleteGroup($viewOptgroup.label);
                    }
                    //Add remaining options to respective optgroup.
                    if (optgroupOptions.length != 0) {
                        this.handleOptions($preOptgroup, optgroupOptions, selectedOption);
                    }

                    //Intentionally left the selection check -> I am relying on the fact that "value" sync event is called after "items" sync.
                },

                "displayValue": function () {
                },
                "placeholder": function(value){
                    // overriding the default handling of place holder options setter
                },
                "access": function (val) {
                    switch (val) {
                        case "open" :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                        case "nonInteractive" :
                        case "protected" :
                        case "readOnly" :
                            this.$userControl.attr("disabled", "disabled");
                            this.$userControl.attr("aria-disabled", "true");
                            break;
                        default  :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                    }
                }
            })
        },

        getEventMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "focus": [xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT, xfalib.ut.XfaUtil.prototype.XFA_PREOPEN_EVENT],
                "change": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
            })
        },

        render: function () {
            var existingInlineStyleAttributeValues = this.element.find("select").attr("style"),
                newInlineStyleAttributeValues,
                combinedInlineStyleAttributeValues,
                size = 1;

            this.element.addClass(this._widgetName);
            this.element.children().remove();

            var inputName = _.uniqueId("select"),  //Unique Id
                textStyle = this.getOrElse(this.$data(this.element.get(0), "xfamodel"), "textstyle", ""),
                $widgetSkeleton = $(this.widgetSkeleton)
                                    .attr('style', textStyle)
                                    .attr('name', inputName);
            if(this.options.editable) {
                $widgetSkeleton.addClass('combobox');
            }

            if(this.options.items && this.options.items.length>0){
                size = this.options.items.length
            }
            if(this.options.multiSelect) {
                $widgetSkeleton.addClass('multiDropdown');
                $widgetSkeleton.attr('multiple','multiple');
                $widgetSkeleton.attr('size',size);
                $widgetSkeleton.attr('data-multiple-selection',"true");
            }

            var $parEl = $widgetSkeleton;
            _.each(this.options.items, function(item){
                var saveItem = _.isString(item.save) ? item.save.replace(/\"/g, "&quot;") : "";
                if (saveItem === this.AF_OPTGROUP_NAME){ // assuming optgroups appear before options
                    $parEl = $(this.optGroupSkeleton).attr('label', item.display).appendTo($widgetSkeleton);
                } else {
                    $(this.optionSkeleton).val(saveItem).text(item.display).appendTo($parEl);
                }
            },this);

            this.element.append($widgetSkeleton);

            var control = this.element.children().eq(0).attr("name", this.options.name);
            this._attachEventHandlers(control);
            newInlineStyleAttributeValues = this.element.find("select").attr("style");
            //append the previous inlineStyleAttributeValues to newInlineStyleAttributeValues so that the inline styles
            //added from the dialog are applied.
            combinedInlineStyleAttributeValues = newInlineStyleAttributeValues + existingInlineStyleAttributeValues;
            this.element.find("select").attr("style", combinedInlineStyleAttributeValues);
            return control;
        },

        //syncs the options to the optgroup dynamically.
        handleOptions : function ($viewOptgroup, val, selectedOption) {
            //When the list so far consists purely of options.
            if (_.isUndefined($viewOptgroup)) {
                $viewOptgroup = this.$userControl[0];
            }
            var viewOptions = $("option[data-user-option]", $viewOptgroup);
            //Syncs the value of options.
            for (var i = 0, j = 0; i < viewOptions.length && j < val.length; i++, j++) {
                var $viewOption = viewOptions[i];
                var element = val[j];
                if ($viewOption.text != element.display) {
                    $viewOption.text = element.display || '';
                }
                if ($viewOption.value != element.save) {
                    $viewOption.value = element.save || '';
                }
            }
            //Deletes options if count is more than required.
            while (i < viewOptions.length) {
                this.deleteOption(viewOptions[i++])
            }
            //Add options if count is less than required.
            while (j < val.length) {
                this.addOption($viewOptgroup, val[j++], selectedOption);
            }
            // Set empty value to dropdown if placeholder and default value is not present
            if (this.options.placeholder.length == 0) {
            	if (this.checkForEmptyValue(this.options.value)) {
            		this.$userControl[0].value = "";
            	}
            }
        },

        addOption : function ($viewOptgroup, element, selectedOption) {
            var $newOption = $(this.optionSkeleton).val(element.save).text(element.display);
            $newOption.appendTo($viewOptgroup);
            if(selectedOption) {
                if(element.save === selectedOption.val() && element.display === selectedOption.text()) {
                    $newOption.prop("selected", true);
                }
            }
            // Since the displayValue is a '\n' separated string of selected values in case of multiSelect,
            // we convert it to an array and check whether that array contains the save value of the element
            var values;
            if (this.options.value && _.isString(this.options.value)) {
                values = this.options.value.split('\n');
            } else if (_.isArray(this.options.value)) {
                // In the case of AF we have value/displayValue as an array
                values = this.options.value
            }
            if (values && values.indexOf(element.save) >= 0) {
                //Delete emptyValue with no placeholder text configured and value is found in options
                if (this.options.placeholder.length == 0 && this.$userControl.children('[data-empty-option]').length > 0) {
                    this.$userControl[0].removeChild(this.$userControl.children('[data-empty-option]')[0]);
                }
                this.$userControl.children().filter(function() {
                    return this.value == element.save;
                }).prop("selected", true);
            }
        },

        deleteOption: function ($viewOption) {
            this.$userControl.find('option[value='+$viewOption.value+']').remove();
        },

        checkForEmptyValue: function(value) {
            if ((value && _.isArray(value) && value[0] == null) || (this.options.value == null))
                return true;
            else
                return false;
        },

        addGroup: function(label) {
            //Creates a optgroup Node.
            var optionGroup = document.createElement("OPTGROUP");
            optionGroup.label = label;
            this.$userControl[0].appendChild(optionGroup);
            return optionGroup;
        },

        deleteGroup: function(label) {
            this.$userControl.children().remove('optgroup[label='+label+']');
        },

        addItem: function(itemValues) {
            var newOption = new Option(itemValues.sDisplayVal || '', itemValues.sSaveVal || ''),
                val = this.options.value;
            this.$userControl[0].add(newOption, null);
            // if item has same value as present in options then mark it as selected
            if (_.contains(val, itemValues.sSaveVal)) {
                this.$userControl.find("option[value=" + itemValues.sSaveVal + "]").prop("selected", true);
                var emptyValue = this.$userControl.children('[data-empty-option]');
                if (emptyValue.length > 0 && emptyValue.val() === itemValues.sSaveVal) {
                    this.$userControl[0].removeChild(emptyValue[0]);
                }
            } else if ((val == null || val.length == 0 || val[0] == null) && this.options.placeholder.length == 0) {
                // Value should remain empty if option is not already selected & placeholder is empty
                this.$userControl[0].value = "";
            }
        },

        clearItems: function () {
            //Deleting all the options including optGroup except the empty value.
            this.$userControl.children().not('[data-empty-option]').remove();
        },

        deleteItem: function (nIndex) {
            //check for emptyValue instead of blindly doing + 1
            if (this.$userControl[0].item(0) && this.$userControl[0].item(0).id == "emptyValue")
                nIndex = nIndex + 1;
            //if there is emptyValue element then just delete one index higher
            //this check is must instead of blindly increasing the index by 1 because NWKListBox extends this class and that doesn't maintain emptyValue
            this.$userControl[0].remove(nIndex);
        },

        getCommitValue: function (event) {
            var value = $("option:selected", this.$userControl).map(function () {
                return $(this).val();
            }).get();
            return value;
        },

        showDisplayValue: function () {
        },

        destroy: function () {
            this.element.
                removeClass(this._widgetName).
                children().remove().
                text("");

            // call the base destroy function
            $.xfaWidget.defaultWidget.prototype.destroy.apply(this, arguments);
        },

        _handleKeyDown: function (event) {

            if (event.keyCode == 13) {
                //do nothing
                //just override the return key behaviour and over to defaultWidget for rest of the stuff.
                //return key is intercepted to avoid submission of form which is default behavior of html form element
                //but as a side effect it also stops the closing of drop down only in IE -> probably I should use IE condition but
                // this code works fine in          chrome as well so keeping it that way.
                //watson bug#3675141
            }
            else
                $.xfaWidget.defaultWidget.prototype._handleKeyDown.apply(this, arguments);
        },

        // CQ-51462 : focus and commit event (change) happen together hence first selection was modifying the value
        // we do not want focus to modify the value that is about to be committed
        showValue : function() {

        }
    });
})($, _);
(function($, _){
	$.widget( "xfaWidget.listBox", $.xfaWidget.defaultWidget, {

    _widgetName: "listBoxWidget",

    options : {
        value : [],
        items : [],
        multiSelect : false
    },

    getOptionsMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "width" : function(val) {
                //Bug#3597771. setting the height more than 0.95 brings scrollbar
                this.options.width = val*0.95
                parentOptionsMap.width.apply(this,[this.options.width])
            },
            "access" : function() {},
            "value": function(val) {
                var newValues = this.options.value,
                    self = this,
                    tabSet = false;
                if(!_.isArray(newValues))
                    newValues = [newValues];
                var tabSet
                this.$userControl.children().each(function(){
                    var saveVal = $(this).attr("data-save");

                    // Check if this value is present in options value array
                    if(newValues && _.contains(newValues, saveVal)){
                        self._selectListItem($(this));
                        tabSet = true;

                        // Set the selected data attribute to true.
                        if (!$.data(this, "_xfaInitialized")) {
                            //Initialized data- attributes parse for once using this call.
                            // Next onward don't use this. Instead use $.data which is cheap/
                            $(this).data();
                            $.data(this, "_xfaInitialized", true); //Mark the element to say that data has been initialized.
                        }
                        $.data(this, "selected", true);

                    }
                    else{
                        $(this).removeClass("item-selected");
                        $(this).addClass("item-selectable");
                        $(this).attr("tabIndex", "-1");
                    }
                });
                if(!tabSet) {
                    $(this.$userControl.children().get(0)).attr("tabIndex", this.options.tabIndex);
                }
            },

            "items" : function(val) {
                if(!_.isArray(val))
                    val = [val];
                var viewItems = this.$userControl.children();

                //if number of items are not same in model and view then balance it
                if((viewItems.length) > val.length){
                    for(var i=viewItems.length; i >  val.length; i--){
                        this.deleteItem(i-1);
                    }
                }
                else if((viewItems.length) < val.length){
                    for(var i=viewItems.length; i < (val.length); i++){
                        this.addItem({sDisplayVal: val[i].display, sSaveVal: val[i].save});
                    }
                }

                _.each(val, function(element, index){
                    var $viewItem = $(viewItems[index]);
                    if( $viewItem.text() != element.display){
                        $viewItem.text(element.display || '');
                    }

                    if( $viewItem.attr("data-save") != element.save){
                        $viewItem.attr("data-save", element.save || '');
                    }
                });

                //Intentionally left the selection check -> I am relying on the fact that "value" sync event is called after "items" sync.
            },

            "displayValue" : function(){;},

            "tabIndex": function() {
                var selectedItem = this.$userControl.children(".item-selected"),
                    children =this.$userControl.children()
                if(selectedItem.length) {
                    selectedItem.eq(0).attr("tabIndex", this.options.tabIndex);
                }
                else if(children.length > 0) {
                    children.eq(0).attr("tabIndex", this.options.tabIndex);
                }
            }
        })
    },

    getEventMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "listboxenter":xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
            "listboxexit":xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
            "listboxchange":xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
            "focus":null,
            "blur":null
        })
    },

    showDisplayValue : function() {
        },

    render : function() {
        this.element.addClass( this._widgetName);
        this.element.children().remove();

        //TODO: add a function for geting textStyle
        var textStyle = this.getOrElse(this.$data(this.element.get(0), "xfamodel"), "textstyle", ""),
            that = this,
            //Bug#3597771 width and height are provided by the view itself.
            listElTemplate =
            '<ol style="position:absolute;<%=textStyle%>" role="listbox">' +
                '<% _.each(items, function(item){ %>' +
                '<% var saveItem = item.save ? item.save.replace(/\"/g,"&quot;"):null %>'+
                    '<li role="option" data-save="<% print(saveItem) %>" data-selected="false"><% print(item.display) %></li>'+
                '<%})%>'+
            '</ol>',
            compiledListElTemplate = _.template(listElTemplate),
            templateOptions = _.extend({
                "textStyle" : textStyle
                }, this.options),
            resolvedListEl = compiledListElTemplate(templateOptions);
        that.element.html(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(resolvedListEl));
        var control = $(that.element.children().get(0)).attr("name",this.options.name);
        this._attachEventHandlers(control);
        return control
    },

    focus: function() {
        if(this.$userControl.children(".item-selected").length > 0) {
            this.$userControl.children(".item-selected")[0].focus();
        }
        else if(this.$userControl.children().length > 0) {
            this.$userControl.children()[0].focus();
        }
    },

    addItem : function(itemValues){
        $("<li></li>")
            .attr("data-save", itemValues.sSaveVal || '')
            .text(itemValues.sDisplayVal || '')
            .appendTo(this.$userControl)
            .click($.proxy(this._handleItemClick, this))
            .focus($.proxy(this._handleItemFocus, this));

        // add new item as selected if the value is already present in options
        if (_.contains(this.options.value, itemValues.sSaveVal)) {
            this._selectListItem(this.$userControl.find("[data-save=" + itemValues.sSaveVal+ "]"));
        }
    },

    clearItems : function(){
        $(this.$userControl).empty();
    },

    deleteItem : function(nIndex){
        $(this.$userControl).children('li').each(function(index,element){
            if(index==nIndex){
                $(element).off("click").off("focus").remove();
            }
        })
    },


    _attachEventHandlers : function($control){
        var self = this;
        $control.keydown($.proxy(this._hotKeys,this))
            .children().on("mousedown",function() {
                    if(self.inFocus == true) {
                        self.mouseDown = true;
                    }
                })
            .click($.proxy(this._handleItemClick, this))
            .focus($.proxy(this._handleItemFocus, this))
            .blur($.proxy(this._handleFocusOut,this))

    },

     _hotKeys : function(event){
         if(this.options.access != "open")
             return;
         if(this.itemInFocus){
             switch(event.which) {
                 case 38: //arrow up
                     var prevSibling = $(this.itemInFocus).prev();
                     if(prevSibling){
                         this.keyDown = true;
                         prevSibling.focus();
                         this.keyDown = false;
                     }
                     event.preventDefault();
                     break;
                 case 40: //arrow down
                     var nextSibling = $(this.itemInFocus).next();
                     if(nextSibling){
                         this.keyDown = true;
                         nextSibling.focus();
                         this.keyDown = false;
                     }
                     event.preventDefault();
                     break;
                 case 91: //left arrow
                 case 92: //right arrow
                     event.preventDefault();
                     break;
                 case 32:
                     this._toggleItem(this.itemInFocus);
                     event.preventDefault();
                     break;
                 default:
             }
         }
     },

     _toggleItem: function(item) {
         var $item = $(item),
             multiMode = this.options.multiSelect, // && event.ctrlKey ;
             that = this;
             //toggle selected state of this item
             this.$data(item, "selected", !this.$data(item, "selected"));
         var state = this.$data(item, "selected")

         if(!multiMode) {
             var $selectedItem = this.$userControl.children(".item-selected")
             if($selectedItem.length) {
                 this.$data($selectedItem[0],"selected",false)
                 $selectedItem.removeClass("item-selected").addClass("item-selectable")
             }
         }
         $item.toggleClass("item-selectable",!state).
               toggleClass("item-selected",state)

         this.$userControl.trigger("listboxchange");
     },

     getCommitValue: function() {
         var that = this,
             multiMode = this.options.multiSelect;


         return this.$userControl.children().map(function(){
             // intentionally using $this.attr("data-save") instead of $this.data("data")
             return that.$data(this, "selected") ? $(this).attr("data-save") : null;
         }).get();
     },

      _handleItemFocus : function(event){
          if(this.options.access != "open")
              return;
          var item = event.target;
          this.itemInFocus = item;

          // overriding default widgets handleFocus
          if(!(this.keyDown || this.mouseDown)) {        //we do not need to fire focus event if
              this.$userControl.trigger("listboxenter")  // clicked on another li element or pressed a key to move the selectio
          }
          this.mouseDown = false;
          this.inFocus = true;
      },

     _handleItemClick : function(event){
        // Bug#3501811 If clicked onlistbox entry more than once, exit event is not fired
        // Clicking on the same entry does not call focus and hence we were not resetting the state. Doing it in onClick
        if(this.mouseDown == true)
            this.mouseDown = false;
        if(this.options.access != "open")
             return;
        this._toggleItem(event.target)
    },

    _handleFocusOut: function(){
        if(!(this.keyDown || this.mouseDown)) {
            this.$userControl.trigger("listboxexit");
            this.inFocus = false
        }
    },

    _selectListItem : function ($elem) {
        if ($elem && $elem.length) {
            $elem.removeClass("item-selectable")
                .addClass("item-selected")
                .attr("tabIndex", this.options.tabIndex);
        }
    },

    destroy: function() {
        this.element.
            removeClass(this._widgetName).
            children().remove().
            text("");

        $.xfaWidget.defaultWidget.prototype.destroy.apply(this, arguments);
    }
});
})($, window._);
(function($) {
    $.widget( "xfaWidget.nwkListBox",  $.xfaWidget.dropDownList, {            //non-webkit listbox

        _widgetName : "nwkListBox",

        options : {
            value : [],
            multiSelect : false
        },

        render : function() {
            var $control = $.xfaWidget.dropDownList.prototype.render.apply(this, arguments);
            if($control){
                $control.children("#emptyValue").remove();
                if(this.options.multiSelect)
                    $control.attr("multiple", "multiple");
            }
            this._updateSelectSize($control);
            return $control;
        },

        addItem : function(itemValues){
            $.xfaWidget.dropDownList.prototype.addItem.apply(this, arguments);
            this._updateSelectSize();
        },

        clearItems : function(){
            $.xfaWidget.dropDownList.prototype.clearItems.apply(this, arguments);
            this._updateSelectSize();
        },

        deleteItem : function(nIndex){
            $.xfaWidget.dropDownList.prototype.deleteItem.apply(this, arguments);
            this._updateSelectSize();
        },

        _updateSelectSize : function($control){
            $control = $control || this.$userControl;
            $control.attr("size", (this.options.items || []).length);
        },

        // Bug#3597771
        // focus and commit event happen together hence first selection was modifying the value
        // we do not want focus to modify the value that is about to be committed
        showValue : function() {

        }

  });
})($);
(function ($) {
    $.widget("xfaWidget.xfaButton", $.xfaWidget.defaultWidget, {            //commitEvent: change; commitProperty: value<Array>

        _widgetName: "xfaButton",

        options: {
            value: null,
            svgCaption: false //option to indicate if button already has an SVG caption
        },

        getOptionsMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "access": function (val) {
                    switch (val) {
                        case "open" :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                        case "nonInteractive" :
                        case "protected" :
                        case "readOnly" :
                            this.$userControl.attr("disabled", "disabled");
                            this.$userControl.attr("aria-disabled", "true");
                            break;
                        default  :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                    }
                },
                "value": function () {
                },
                "displayValue": function () {
                },
                "svgCaption": function (val) {
                    if (val) {
                        this.$userControl.removeAttr("value");
                    }
                }
            })
        },

        _attachEventHandlers: function ($control) {
            $control.click(function () {
                this.focus()
            });
        },

        getCommitValue: function () {
            return this.options.value;
        },

        showValue: function () {
        },

        showDisplayValue: function () {
        }
    });
})($);(function ($) {
    $.widget("xfaWidget.XfaCheckBox", $.xfaWidget.defaultWidget, {            //commitEvent: change; commitProperty: value<Array>

        _widgetName: "XfaCheckBox",

        options: {
            value: null,
            state: -1,
            states: 2,
            values: [],
            mandatory: false
        },

        checkedState: false,
        clickPending: false,

        getOptionsMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "access": function (val) {
                    switch (val) {
                        case "open" :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                        case "nonInteractive" :
                        case "protected" :
                        case "readOnly" :
                            this.$userControl.attr("disabled", "disabled");
                            this.$userControl.attr("aria-disabled", "true");
                            break;
                        default  :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                    }
                },

                "displayValue": function (val) {
                    this.$userControl.attr(this.options.commitProperty, this.options.value);
                    this._state(this.dIndexOf(this.options.values, this.options.value));
                    this.$userControl.attr("checked", this.checkedState ? "checked" : null);
                    this.$userControl.prop("checked", this.checkedState ? "checked" : null);
                    //for accessibility
                    this.$userControl.attr("aria-checked", this.checkedState);
                    if (this.options.state == 2)
                        this.$userControl.addClass("neutral");
                    else if (this.options.states == 3)
                        this.$userControl.removeClass("neutral");   // since current state != neutral
                },

                "allowNeutral": function (val) {
                    var intVal = parseInt(val);
                    if (intVal == 0 || intVal == 1) {
                        this.options.states = 2 + intVal;
                    }
                },

                "paraStyles": function (paraStyles) {
                    parentOptionsMap.paraStyles.apply(this, arguments);
                    this._handleVAlignOnExit();
                }
            })
        },

        getEventMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                 "xfacheckboxchange" :  xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                 "xfacheckboxclick" :   xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT,
                 "change": null,
                 "click" : null
               })
        },

        _attachEventHandlers: function ($control) {
            var that = this;
            var focusFunc = function (evnt) {
                if (!that.inFocus) {
                    that.focus();
                    that.inFocus = true;
                }
            }
            var focusOutFunc = function (evnt) {
                that.inFocus = false;
            }
            $control.click(focusFunc).change(focusFunc).blur(focusOutFunc);
            $control.change($.proxy(this._handleChange,this)).click($.proxy(this._handleClick,this));   //LC-5106
        },

        getCommitValue: function () {
            this._state((this.options.state + 1) % this.options.states);
            this.$userControl.attr("checked", this.checkedState ? "checked" : null);
            //for accessibility
            this.$userControl.attr("aria-checked", this.checkedState)
            if (this.options.state == 2) {
                this.$userControl.addClass("neutral");
            }
            else if (this.options.states == 3)
                this.$userControl.removeClass("neutral"); // since current state != neutral

            return this.options.values[this.options.state];
        },

        _handleVAlignOnExit: function (evnt) {
            //--this is being kept empty as no other browser (i.e Mozilla and Chrome) take the padding-bottom or padding-top into account.
            // the only browser to take it into consideration is IE. And moreover the alignment and padding considerations have already been taken into account in
            // calculations in CheckButtonFieldView.js. And on removing the entire function it takes up the _handleVAlignOnExit() of AbstractWidget.

        },

        _handleChange: function (evnt) {
            this.$userControl.trigger("xfacheckboxchange"); //change is always fired
            if(this.clickPending === true) {
              this.clickPending = false;
              this.$userControl.trigger("xfacheckboxclick");
            } else {
                // handling of this.clickPending is added to handle the case when clicked on checkbox/radiobutton label/caption
                this.clickPending = true;
            }
        },

        _handleClick: function (evnt) {
             var isChrome = xfalib.ut.XfaUtil.prototype.detectChrome(),
                 isIE = xfalib.ut.XfaUtil.prototype.detectIE(),
                 isSafari = xfalib.ut.XfaUtil.prototype.isSafari(),
                 userControlType = this.$userControl.attr("type");
             // click will not be fired if the previous state of the radiobutton is 'on'.
             // NPR-35652 : Checkbox movement - Click event works fine on chrome but not in iOS safari for collapsible fields
             // CQ-103023 : Click Event on Radio Button not working correctly in Chrome 53
             // CQ-103715 : CQ-103715 : Click Event on Check Box not working correctly in Chrome and Firefox, added handling for checkbox also
             // handling of this.clickPending is added to handle the case when clicked on checkbox/radiobutton label/caption
             if(($.browser.mozilla || isChrome || isSafari) && !isIE && this.clickPending === false && ((userControlType === "radio" && this.checkedState === false) || (userControlType === "checkbox"))) {
               this.clickPending = true;
             }
             else {
                this.$userControl.trigger("xfacheckboxclick");
                this.clickPending = false;
             }
        },

        _state: function (newState) {
            if (newState == undefined)
                return this.options.state;
            else
                this.options.state = newState;
            this.checkedState = (newState == 0 || newState == 2);
        },

        click: function () {
            // trigger change for check box and for radio only if it is not selected
            // otherwise radio button will go in deselected state
            if (this.$userControl.attr("type") !== "radio" || this.options.state !== 0) {
                this.$userControl.trigger("change");
            }
            //we should call only the handler since calling click will trigger change.
            this.$userControl.triggerHandler("click");
        }
    });
})($);
(function($, _){
    $.widget( "xfaWidget.textField", $.xfaWidget.defaultWidget, {

        _widgetName: "textField",

        options: {
            curValue : null ,
            pos:0,
            lengthLimitVisible: true,
            maxChars:0 ,
            flag:"",
            // by default html5Type is set to true
            // we leverage pattern, maxLength support from HTML5 browser for mobile forms
            html5Type : "text",
            length : null,
            minLength : 0,
            totalLengthMessage : "",
            minimumLengthMessage : "",
        },

        getOptionsMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
            return $.extend({},parentOptionsMap,{
                "maxChars": function(maxchars) {
                    if(this._maxCharsReached(this.options.value)) {
                        var value = this.options.value.slice(0,maxchars)
                        this._setOption("value", value);
                        this._setOption("displayValue", value);
                    }

                },

                "multiLine ": function(val) {
                    if(this.options.multiLine)
                        this.$userControl.attr("aria-multiline", "true");
                    else
                        this.$userControl.removeAttr("aria-multiline", "false");
                },

                "height": function(val) {
                    if(val)   {
                        this.$css(this.$userControl[0],{"height" :val})
                        this._handleVAlignOnExit();    // To Handle the case of expandable Fields
                    }
                },
                "width": function(val){
                    parentOptionsMap.width.apply(this,arguments);
                    // handle valign on width change as well
                    // as content height(scrollHeight) varies according to width
                    this._handleVAlignOnExit();
                },
                "paraStyles": function(paraStyles){
                    parentOptionsMap.paraStyles.apply(this,arguments);
                    this._handleVAlignOnExit();
                }

            })
        },

        render : function() {
            var control = $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
            // use the control to set HTML5 attributes
            if (control && control.length > 0 && this.options.html5Type) {
                var minLength = this.options.minLength,
                    maxLength = this.options.maxChars,
                    length = this.options.length;
                    isMinLengthSet = minLength != null && minLength > 0,
                    isMaxLengthSet = maxLength != null && maxLength > 0,
                    isLengthSet = length != null && length > 0,
                    isMultiline = this.options.multiLine,
                    minLengthMsg = this.options.minimumLengthMessage,
                    totLengthMsg = this.options.totalLengthMessage,
                    pattern = ""; // html5 pattern is not supported for textarea

                // order of execution matters for the below code snippet
                if (isMinLengthSet) {
                    // add minLength though it is not fully supported in all browsers
                    // hence also adding pattern attribute
                    control.attr("minlength", parseInt(minLength));
                    if(minLengthMsg && minLengthMsg.length > 0) {
                        control.attr("title", this.options.minimumLengthMessage); // html5 supported message on pattern validation failure
                    }
                }

                if (isMaxLengthSet) {
                    control.attr("maxlength", parseInt(maxLength));
                }

                // if both min and max length is set
                if(isMinLengthSet && isMaxLengthSet){
                    pattern += ".{" + minLength + "," + maxLength + "}";
                } else if(isMinLengthSet) {
                    // if only min length set
                    pattern += ".{" + minLength + ",}";
                }

                // if length is set then set min and max length in pattern equal to length
                if (isLengthSet) {
                    if(isMultiline){ // set both min and maxlength as pattern is not supported
                        control.attr("minlength", parseInt(length));
                        control.attr("maxlength", parseInt(length));
                    }
                    if(totLengthMsg && totLengthMsg.length > 0) {
                        control.attr("title", this.options.totalLengthMessage);
                    }
                    // reset the pattern string
                    pattern = ".{" + length + "," + length + "}";
                }
                // if required is set, set the required attribute, it is necessary else an empty value will be excluded from constraint validation
                if (this.options.required) {
                    control.attr("required", true);
                }
                // set the pattern if not empty and check if this is not multiline, since pattern is not supported for textarea
                if (pattern && pattern.length > 0 && !isMultiline) {
                    control.attr("pattern", pattern);
                }
            }
            return control;
        },

        /*  This function aligns vAlign when:
         1. parastyles is present and the widget contains a value.
         2. During initial rendering if no content present fallback to the previous logic.
         3. Presence of content in widget.
        */
        _handleVAlignOnExit: function(){
             var value = this.options.displayValue,
                 noContentPresent = _.isEmpty(this.$userControl.val() || this.options.displayValue),
                 contentHeight,widgetHeight,diff,tempCSS;

             //the widget doesn't have value as yet but content exists [ Rendering of widget]
             if (!this.options.paraStyles || noContentPresent) {
                //vAlign has to be handled only if there is paraStyles and widget has content
                return;
             }

             // mozilla results in vAlign regression hence made this change only for textarea
             if($(this.element[0]).find("textarea").length >0 && !noContentPresent)  {
               /* measureExtent not returning correct height of content in textarea even with all
                 css values */
               tempCSS={'height':this.$userControl.css('height'),'padding':this.$userControl.css('padding')};
               this.$css(this.$userControl[0],{'height':'1px','padding':'0px'});

               contentHeight = this._getContentHeight();
               this.$css(this.$userControl[0],tempCSS);
               widgetHeight = this.options.height;
               diff = widgetHeight - contentHeight;
               this._calculatePaddingForVAlign(diff);
             } else {
                // widget has no initial content or is a textfield.Proceed as before.
                $.xfaWidget.defaultWidget.prototype._handleVAlignOnExit.apply(this,arguments);
             }
        },

        getEventMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
            return $.extend({},parentOptionsMap,{
                "onKeyInput.textField" : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
            })
        },

        _maxCharsReached: function(val) {
            var isMaxLengthSupported = false,
                elementName = this.options.multiLine ? "textarea" : "input";
            // in browsers, where max length is supported, we don't custom javascript checks, we let HTML do the validation of max length
            if(this.options.html5Type && xfalib.view.util.HtmlUtil.elementSupportsAttribute(elementName, "maxLength")){
                isMaxLengthSupported = true;
            }
            return !isMaxLengthSupported && this.options.maxChars
                   && this.options.maxChars!=="0"
                   && val
                   &&  val.length >= this.options.maxChars
        },

        _handleKeyInput : function(event, character, code) {
            if(event.ctrlKey && !_.contains(['paste', 'cut'], event.type)) {
                return true;
            }

            if(!this.options.multiLine) {
                $.xfaWidget.defaultWidget.prototype._handleKeyDown.apply(this, arguments);
                character = (code == 13) ? '' : character ;
            }

            var val =  this.$userControl.val(),
                selectionStart = xfalib.view.util.HtmlUtil.getHTMLSupportedAttr(this.$userControl[0], "selectionStart") || 0,
                selectionEnd = xfalib.view.util.HtmlUtil.getHTMLSupportedAttr(this.$userControl[0], "selectionEnd") || 0,
                pos = selectionStart,
                // CQ-4260239 : "&nbsp" taking space of 5 chars for restricting the length to visible area
                newVal = (val.substr(0, selectionStart) + character + val.substr(selectionEnd));
            this.options.curValue = val;
            if(!this.options.multiLine) { //TODO:looks like a bug
                this.options.lengthLimitVisible = true;
                this.options.pos = pos;
                if(this.options.hScrollDisabled && !_.contains(['keydown', 'cut'], event.type)) {
                    var expectedWidth = xfalib.view.util.TextMetrics.measureExtent(newVal, {refEl: this.$userControl[0], maxWidth:-1}).width;
                    if(!event.ctrlKey && expectedWidth > this.$userControl.width()){   // Why  allowance of 5 required??
                        this.options.lengthLimitVisible = false;
                        event.preventDefault();
                        return false;
                    }
                }
            } else if (this.options.multiLine && this.options.hScrollDisabled) {  // LC-4656 : wait till user input, if it causes an overflow revert to old text
                var $textArea = this.$userControl;
                $textArea.css("padding", "0px 0px 0px");  // TODO : take care of multiline selection & padding later

                // TODO : find a scheme to avoid attaching and detaching listeners, currently $.val() causes 'input' to fire, resulting in an infinite loop
                $textArea.one("input", function () {
                    if ($textArea.prop('scrollHeight') > $textArea.prop('offsetHeight')) {
                        $textArea.val(val)
                                 .prop("selectionStart", selectionEnd)
                                 .prop("selectionEnd", selectionEnd);  // LC-4656 : reset the cursor pos, afterwards
                        character = null;
                        code = 0;
                    }
                });
            }

            if (!_.contains(['keydown', 'cut'], event.type) && this._maxCharsReached(val) && selectionStart === selectionEnd) {
                event.preventDefault();
                return false;
            }

            this.$userControl.trigger({
                type : "onKeyInput.textField",
                originalType : event.type,
                character : character,  // contains the pasted string or pressed key
                keyCode : event.keyCode || 0,
                charCode : event.charCode || 0,
                which : event.which || 0,
                ctrlKey : event.ctrlKey || event.metaKey || false,
                shiftKey : event.shiftKey || false,
                keyDown: false, // This property is available only for list boxes and drop-down lists
                selectionStart: selectionStart,
                selectionEnd: selectionEnd
            });
        },

        _handleKeyDown : function(event){
            if (event) {
                var code = event.charCode || event.which || event.keyCode || 0;
                if(code == 8 || code == 46) // backspace and del
                   this._handleKeyInput(event, "", code);
            }
        },

        _handleKeyPress : function(event){
            if (event) {
                var code = event.charCode || event.which || event.keyCode || 0,
                    character = (code == 13) ? "\n" : String.fromCharCode(code); // modified '\r\n' -> '\n'

            if(xfalib.ut.XfaUtil.prototype.isNonPrintableKey(event.key)) { // mozilla also generates a keypress, along with keydown
                return true;                                               // for all keys, so only handling printable keys in keypress
            }

            this._handleKeyInput(event, character, code);
            }
        },

        _compositionUpdateCallback : function (event) {
            var that = this;
            var val = that.$userControl.val();
            if (event.type === "compositionupdate" && event.originalEvent.data) {
                // this has been deliberately done to get the actual data in case of max character.
                if (that.options.maxChars) {
                    val = event.originalEvent.data;
                } else {
                    val = val + event.originalEvent.data.substr(event.originalEvent.data.length - 1);
                }
            }
            var flag = that._maxCharsReached(val);
            if (flag) {
                // if max reached
                var newVal = val.substr(0, that.options.maxChars);
                //in case the value is not changed then we do not need to update value and close the android keyboard.
                if (val === newVal) {
                    return false;
                }
                that.$userControl.val(newVal);
            }
            return flag;
        },

        _attachEventHandlers: function($control) {
            $.xfaWidget.defaultWidget.prototype._attachEventHandlers.apply(this, arguments);
            // IME specific handling, to handle japanese languages max limit
            $.xfaWidget.defaultWidget.prototype._attachCompositionEventHandlers.apply(this, arguments);
        },

        _handlePaste : function(event){
            if (event) {
                var pastedChar = undefined;
                if (window.clipboardData && window.clipboardData.getData) { // IE
                    pastedChar = window.clipboardData.getData('Text');
                } else if (event.originalEvent.clipboardData && event.originalEvent.clipboardData.getData) {
                    pastedChar = event.originalEvent.clipboardData.getData('text/plain');
                }
                if(pastedChar) {
                    this._handleKeyInput(event, pastedChar, 0);
                }
            }
        },

        _handleCut : function(event) {
            if (event) {
                this._handleKeyInput(event, "", 0);
            }
        },

        postProcessExit: function(evnt) {
            $.xfaWidget.defaultWidget.prototype.postProcessExit.apply(this,arguments);
            if (this.options.multiLine && this.options.hScrollDisabled) {
                return;
            }
            this._handleVAlignOnExit();
        },

        preProcessEnter: function(evnt) {
            $.xfaWidget.defaultWidget.prototype.preProcessEnter.apply(this,arguments);
            if(this.options.multiLine && this.options.hScrollDisabled)
                return;
            this._handleVAlignOnEnter();
        },

        /**
         * @brief: Select the given field on focus in Internet Explorer
         *
         */
        _selectOnFocusInIE : function(){
            // if the value is not same only then do selection in IE
            // For Issue: LC-9895, we check if value not same
            if($.browser.msie && !this._isValueSame()) {
                this.$userControl.select();
            }
            else {
                //all other browsers behave like a good boy
            }
        },

        showValue : function() {
            $.xfaWidget.defaultWidget.prototype.showValue.apply(this,arguments);
            //IE doesn't show selected text if we focus and set its value all the time so force selection
            this._selectOnFocusInIE();
        },

        getCommitValue: function() {
            var value = $.xfaWidget.defaultWidget.prototype.getCommitValue.apply(this, arguments);

            if(this._maxCharsReached(value)) {
                value = value.slice(0,this.options.maxChars);
            }

            this.$userControl.val(this.options.value);

            //TODO: ask Sharad whether it is right
            if(this.options.multiLine && this.options.hScrollDisabled)  {
                //var str= this._checkLines(value);
                //if(value != str) {
                    return value;
                //}
            }
            return value;
        },

        /*
        ** returns the contentHeight which needs to be considered for padding for valign,
        ** if no contentHeight is present then fontSize is returned.
        */
        _getContentHeight: function () {
            var contentHeight = Math.ceil(this.$userControl.get(0).scrollHeight);
            return contentHeight ? contentHeight : this.options.fontSize;
        }
    });
})($, window._);
/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2019 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/

(function ($) {
    $.widget("xfaWidget.richTextField", $.xfaWidget.textField, {

        _widgetName : "richTextField",

        _richTextWidget : null,

        _changeAccess : function (val) {
            switch (val) {
                case "open":
                    if (this._richTextWidget) {
                        this._richTextWidget.editor.enable();
                        this._richTextWidget.$toolbar.removeClass("hideToolbar");
                    }
                    break;
                case "readOnly":
                    if (this._richTextWidget) {
                        this._richTextWidget.editor.disable();
                        this._richTextWidget.$toolbar.addClass("hideToolbar");
                    }
                    break;
            }
        },

        getOptionsMap : function () {
            var parentOptionsMap = $.xfaWidget.textField.prototype.getOptionsMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "value" : function (val) {
                    if (this._richTextWidget) {
                        this._richTextWidget.setRichTextEditorContent(val);
                    }
                },
                "access" : function (val) {
                    this._changeAccess(val);
                }
            });
        },

        getEventMap : function () {
            // in case of IE browsers, focus event is delayed, hence adding activate method for content editable
            if (xfalib.ut.XfaUtil.prototype.isIE()) {
                var parentOptionsMap = $.xfaWidget.textField.prototype.getEventMap.apply(this, arguments);
                return $.extend({}, parentOptionsMap, {
                    "activate.richTextField" : xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT
                });
            } else {
                return $.xfaWidget.textField.prototype.getEventMap.apply(this, arguments);
            }
        },

        render : function () {
            var $richTextWidget = this.element.find("div.richTextWidget").eq(0);
            if(!$richTextWidget.length){
                var attachedTextareaClasses = this.element.children().attr('class');
                var richTextWidgetElement = '<div class="richTextWidget ' + attachedTextareaClasses + '" id="richTextField_' + this.options.name + '_' + attachedTextareaClasses + '"></div>';
                this.element.children().remove();
                this.element.append(richTextWidgetElement);
                $richTextWidget = this.element.find("div.richTextWidget").eq(0);
            }else{
                $richTextWidget.children().remove();
            }
            $richTextWidget.append(this.options.value);
            return $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
        },

        getCommitValue : function () {
            var value = "";
            if (this._richTextWidget) {
                value = this._richTextWidget.getRichTextEditorContent();
            }
            return value;
        },

        preProcessEnter : function (evnt) {
            $.xfaWidget.textField.prototype.preProcessEnter.apply(this, arguments);
            var $richTextDiv = this.$userControl.find("div.richTextWidget").eq(0);
            if(!$richTextDiv.length){
                $richTextDiv = this.element.find("div.richTextWidget").eq(0);
                this.changeDefaultToolbarConfig();
                this.$userControl.parents('.richtextsupport').css('z-index', 'auto');
            }
            if (window.Form === undefined || window.Form.rte === undefined) {
                /* Forms RTE is part of Forms Addon package only. Dont do anything if addon is not installed.*/
                return;
            } else if (this._richTextWidget === null) {
                this._initializeRTEToolbar();
                this._richTextWidget = new window.Form.rte.RichTextEditor({
                    selector : $richTextDiv.attr("id"),
                    toolbar : window.Form.rte.RichTextEditor.MFToolbar,
                    data : this.options.value,
                    locale : $richTextDiv.data("locale")
                });
                var that = this;
                this._richTextWidget.editor.on("blur:composer", function () {
                    that.$userControl.trigger("blur");
                });
                // initialize the access
                if (this.options.access) {
                    this._changeAccess(this.options.access);
                }
            }
        },

        changeDefaultToolbarConfig: function(){
            if(window.Form && window.Form.rte){
                var toolbarDefaultConfigData = window.Form.rte.DefaultConfig;
                toolbarDefaultConfigData.fontSize.defaultValue = this.options.fontSize;
                toolbarDefaultConfigData.fontFamily.defaultValue = this.options.fontFamily;

                // Adding 'isFontInPx' flag and overriding two utility functions
                // 'getDefaultParaStyle' and 'getMissingParaStyle' are responsible for adding RTE font styling attributes to rich text elements
                toolbarDefaultConfigData.isFontInPx = true;
                this.changeDefaultParaStyleUtility();
                this.changeMissingParaStyleUtility();

                // Adding dropdown values in default config if not available in options
                if(toolbarDefaultConfigData.fontSize.options.indexOf(this.options.fontSize) === -1){
                    toolbarDefaultConfigData.fontSize.options.push(this.options.fontSize);
                }
                if(toolbarDefaultConfigData.fontFamily.options.indexOf(this.options.fontFamily) === -1){
                    toolbarDefaultConfigData.fontFamily.options.push(this.options.fontFamily);
                }
            }
        },

        changeDefaultParaStyleUtility: function(){
            Form.rte.util.HtmlUtils.getDefaultParaStyle = function (config) {
                var style = "";
                if (config) {
                    style += 'font-family:' + config.fontFamily.defaultValue + ';';
                    if(config.isFontInPx){
                        style += 'font-size:' + config.fontSize.defaultValue + 'px;';
                        style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'px;';
                    }else{
                        style += 'font-size:' + config.fontSize.defaultValue + 'pt;';
                        style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'pt;';
                    }
                    style += 'color:#000000;';
                    style += 'text-align:left;';
                }

                return style;
            };
        },

        changeMissingParaStyleUtility : function(){
            Form.rte.util.HtmlUtils.getMissingParaStyle = function (style, config) {
                if (style && style.length > 0) {
                    if (config) {
                        if (!Form.rte.util.StringHelper.endsWith(style, ";")) {
                            style += ";";
                        }
                        if (style.indexOf("font-family") < 0) {
                            style += 'font-family:' + config.fontFamily.defaultValue + ';';
                        }
                        if (style.indexOf("font-size") < 0) {
                            if(config.isFontInPx){
                                style += 'font-size:' + config.fontSize.defaultValue + 'px;';
                            }else{
                                style += 'font-size:' + config.fontSize.defaultValue + 'pt;';
                            }
                        }
                        if (style.indexOf("letter-spacing") < 0) {
                            if(config.isFontInPx){
                                style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'px;';
                            }else{
                                style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'pt;';
                            }
                        }
                        if (style.indexOf("color") < 0) {
                            style += 'color:#000000;';
                        }
                        if (style.indexOf("text-align") < 0) {
                            style += 'text-align:left;';
                        }
                    }
                } else {
                    style = Form.rte.util.HtmlUtils.getDefaultParaStyle(config);
                }
                return style;
            };
        },

        _initializeRTEToolbar : function () {
            window.Form.rte.RichTextEditor.MFToolbar = window.Form.rte.RichTextEditor.MFToolbar || {
                defaultMode : 'basic',
                toolbars : {
                    basic : {
                        layout : [
                            {
                                items : [Form.rte.Commands.HEADER]
                            },
                            {
                                items : [Form.rte.Commands.BOLD, Form.rte.Commands.ITALIC, Form.rte.Commands.UNDERLINE]
                            },
                            {
                                command : 'lists',
                                icon : 'list',
                                title : "List Type",
                                type : 'popover',
                                placement : 'bottom',
                                items : [Form.rte.Commands.INSERT_UNORDERED_LIST,
                                    Form.rte.Commands.INSERT_ORDERED_LIST,
                                    Form.rte.Commands.INSERT_LOWERCASE_ALPHABET_LIST]
                            },
                            {
                                title : 'Expand',
                                command : Form.rte.Commands.MODE,
                                value : Form.rte.ToolbarMode.FULL,
                                icon : 'resize-full'
                            }
                        ],
                        floating : true
                    },
                    full : {
                        layout : [
                            {
                                items : [Form.rte.Commands.BOLD, Form.rte.Commands.ITALIC, Form.rte.Commands.UNDERLINE]
                            },
                            {
                                items : [Form.rte.Commands.SUPERSCRIPT, Form.rte.Commands.SUBSCRIPT]
                            },
                            {
                                items : [
                                    Form.rte.Commands.HEADER, Form.rte.Commands.FONT_FAMILY, Form.rte.Commands.LINE_HEIGHT, Form.rte.Commands.FORE_COLOR, Form.rte.Commands.HILITE_COLOR, Form.rte.Commands.LINK
                                ]
                            },
                            {
                                items : [Form.rte.Commands.INSERT_UNORDERED_LIST, Form.rte.Commands.INSERT_ORDERED_LIST, Form.rte.Commands.INSERT_LOWERCASE_ALPHABET_LIST
                                ]
                            },
                            {
                                title : 'Collapse',
                                command : Form.rte.Commands.MODE,
                                value : Form.rte.ToolbarMode.BASIC,
                                icon : 'resize-small',
                                selected : true
                            }
                        ]
                    }
                }
            };
        }
    });

})($);(function($){
	$.widget( "xfaWidget.imageField", $.xfaWidget.defaultWidget, {

    _widgetName:"imageField",

    options: {
        tabIndex: 0,
        "role": "img"
    },

    getEventMap: function () {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this, arguments);
        return $.extend({}, parentOptionsMap, {
            "imagechange": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
        })
    },

    getOptionsMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "screenReaderText": function(val) {
                if(val)
                    this.$userControl.attr("alt", val)
            },
            "displayValue": function(val) {
                var widgetValue;
                if (this.options.value) {
                    widgetValue = "data:;base64," + this.options.value;
                } else {
                    widgetValue = "";
                }
                this.$userControl.prop(this.options.commitProperty, widgetValue);
                this.$userControl.attr(this.options.commitProperty, widgetValue);
            },
            "access" : function() {},

            // CQ-85514 : use max-ht & max-wd to honor image's intrinsic ht & wd attributes & prevent distortion
            "height" : function (val) {
                // in case aspect is actual then we need to crop the image, which will be not possible if max height and width are set
                if (val && this.options.aspect != "actual") {
                    this.$css(this.$userControl[0], {"max-height": val});
                }
            },
            "width" : function (val) {
                if (val && this.options.aspect != "actual") {
                    this.$css(this.$userControl[0], {"max-width": val});
                }
            },
            "aspect" : function (val) {
                // value of actual turns off scaling, causing the image to be drawn at its native size,
                // as per xfa spec Adobe implementations crop the image
                if(this.options.aspect == "actual") {
                    var right = this.$userControl.attr("width"),
                        bottom = this.$userControl.attr("height");
                    right = right.indexOf("px") >= 0 ? right : right + "px";
                    bottom = bottom.indexOf("px") >= 0 ? bottom : bottom + "px";
                    this._cropImage("0px", right, bottom, "0px");
                    this.$userControl.removeAttr("height width");
                // value of none indicates no aspect ratio
                // as per xfa spec image is independently scaled in the horizontal and vertical directions to exactly fill the field,
                // which are already set to fill the field
                } else if (this.options.aspect != "none") {
                // A value of fit, which is the default, causes the scale to be such that the image fills as much of the field as possible
                // without overflowing it in either dimension.
                    this.$userControl.attr({"height" : "auto", "width" : "auto"});
                }
            }
        });
    },

    // crop the image using top,right, bottom, left coordiantes of the image
    _cropImage : function (top, right, bottom, left) {
        var clipRect = "rect(" + top + "," + right + "," + bottom + "," + left + ")";
        var clipPathPolygon = "polygon( 0px 0px, 0px " + bottom + "," + right + " " + bottom +"," + right + " 0px)";
        // clip property is deprecated but still supported by all the major browsers
        // clip-path replaces the deprecated clip property but still is not fully supported by all major browser
        this.$userControl.css({"clip" : clipRect, "clip-path" : clipPathPolygon});
    },

    render : function() {
        var self = this;
        if (typeof FileReader !== "undefined") {
            this.reader = new FileReader();
        } else {
            xfalib.ut.XfaUtil.prototype.getLogger().error("Image Field is supported only for HTML5 supported browsers.");
        }
        if (this.element) {
            // change event triggered when new image is selected
            this.$widgetInput = this.element.find("input").on("change.imageField", function() {
                self._handleInputChange();
            }).click(function(event) {
                // to stop bubbling of event from input to widget
                event.stopPropagation();
            });
            this.$widgetImg = this.element.on("click.imageField", function() {
                self._imageClick();
            }).find("img");
        }
        if (this.reader) {
            //load event is triggered each time the reading operation is successfully completed
            this.reader.addEventListener("load", function () {
                self.$widgetImg.attr("src",self.reader.result);
                self.$widgetImg.trigger("imagechange");
            }, false);
        }
        return $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
    },

    getCommitValue: function() {
        return this._extractData(this.$userControl.attr("src"));
    },

    // hidden input change handler, input change will be triggered on selecting a new image
    _handleInputChange : function() {
        this._displayImage();
    },

    _imageClick : function(clickEvent) {
        //as the input button is hidden we trigger click explicitly on click of the widget
        this.$widgetInput.trigger("click");
    },

    // removes "data\:.*\;base64," from the image base64 string
    _extractData : function(value) {
        return value.replace(/data\:.*\;base64,/, "");
    },

    // previews image in the imagefield widget
    _displayImage : function() {
        var imageFile = this.$widgetInput.get(0).files ? this.$widgetInput.get(0).files[0] : null;
        if (imageFile && this._isFileOfImageType(imageFile.name)) {
            if (this.reader) {
                //readAsDataURL method is used to read the contents of the specified file, result attribute contains  the data as a URL representing the file's data as a base64 encoded string
                this.reader.readAsDataURL(imageFile);
            }
        }
    },

    // Test for supported image file(jpg,jpeg,png,gif,tif,bmp)
    _isFileOfImageType : function(fileName) {
        if (fileName) {
            return (/\.(jpe?g|png|gif|tif|bmp)$/i.test(fileName));
        }
        return false;
    }
});
})($);
/**
 * Created with IntelliJ IDEA.
 * User: rpandey
 * Date: 12/24/12
 * Time: 8:06 PM
 * To change this template use File | Settings | File Templates.
 */


(function($){
    $.widget( "xfaWidget.signatureField", $.xfaWidget.defaultWidget, {

        _widgetName:"signatureField",

        getOptionsMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
            return $.extend({},parentOptionsMap,{
                "displayValue": function(val) {},
                "access": function(val) {}
            })
        },

        render : function() {
            var $control = $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
            //pessimistic checks
            if($control) {
                $control.attr("readOnly","readonly").attr("disabled", true);
            }
            return $control;
        }
    });
})($);
/*
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 * Copyright 2011-2012 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 */
 
/**
 * widget definition for scribbleable field
 */
(function($,xfalib){

 var TouchUtil=xfalib.ut.TouchUtil;
 var ScribbleUtil=(function(){
      return {
          localeString:function(id){
                    return xfalib.ut.XfaUtil.prototype.encodeScriptableTags($.xfaWidget.abstractWidget.prototype.localeStrings()[id])  || id;
          }
      };
 })();
 var DELETE_KEY = 46;
 var ESC_KEY = 27;
 var ENTER_KEY = 13;
/**
 * Scribble class definition, used for drawing on canvas using mouse or touch
 */
function Scribble( canvasID,image,_width,_height, callback) {
    this._callback = callback;
    this.canvasID = canvasID;
    this._lineWidth=5;
    this.canvas = $("#"+canvasID);
    this.context = this.canvas.get(0).getContext("2d"); 
    this.context.clearRect(0,0,this.canvas.width,this.canvas.height);
    this._enabled=true;
    this.context.strokeStyle = "#000000";
    this.canvasBorderWidth = parseInt(this.canvas.css('border-left-width'),10); // assuming top and left borders are same width
    this.context.lineWidth = this._lineWidth;
    this.lastMousePoint = {x:0, y:0};
    
    this.canvas[0].width = _width;// this.canvas.parent().innerWidth();
    this.canvas[0].height = _height;//this.canvas.parent().innerHeight();
    if(!image){
        this.context.fillStyle   = '#ffffff';
        this.context.clearRect(0,0,_width,_height);
    } else {
        this.context.drawImage(image,0,0);
    }
    this.canvas.on( TouchUtil.POINTER_DOWN, this.onCanvasMouseDown() );
}
Scribble.prototype.setLineWidth=function(w){
    this._lineWidth=w;
};
Scribble.prototype.onCanvasMouseDown = function () {
    var self = this;
    return function(event) {
        if(TouchUtil.getTouches(event).length < 2){
            self.mouseMoveHandler = self.onCanvasMouseMove();
            self.mouseUpHandler = self.onCanvasMouseUp();
            //CQ-4261765 : Scribble sign scroll issue with ios
            //https://stackoverflow.com/questions/49500339/cant-prevent-touchmove-from-scrolling-window-on-ios
            //https://github.com/jquery/jquery/issues/2871
            document.addEventListener(TouchUtil.POINTER_MOVE, self.mouseMoveHandler,{ passive: false });
            $(document).on(TouchUtil.POINTER_UP, self.mouseUpHandler );
            self.updateMousePosition( event );
            self.updateCanvas( event );
        }
    }
};

Scribble.prototype.onCanvasMouseMove = function () {
    var self = this;
    return function(event) {
        if(TouchUtil.getTouches(event).length < 2){
            self.updateCanvas( event );
            event.preventDefault();
            return false;
        }
    }
};

Scribble.prototype.onCanvasMouseUp = function (event) {
    var self = this;
    return function(event) {
        document.removeEventListener(TouchUtil.POINTER_MOVE, self.mouseMoveHandler,{ passive: false });
        $(document).off(TouchUtil.POINTER_UP, self.mouseUpHandler );
        self.mouseMoveHandler = null;
        self.mouseUpHandler = null;
    }
};

Scribble.prototype.updateMousePosition = function (event) {
    if(!this._enabled) return ;
    var target = TouchUtil.getTouchEvent(event);

    var offset = this.canvas.offset();
    /* In IE>=10 pageX values are incorrect when using zoom
     so calculate them using clientX and scrollLeft */
    this.lastMousePoint.x = target.clientX + $(window).scrollLeft() - offset.left - this.canvasBorderWidth;
    this.lastMousePoint.y = target.clientY + $(window).scrollTop() - offset.top - this.canvasBorderWidth;

};
Scribble.prototype._isInsideCanvas = function(x,y){
    return y>=0 && y<this.canvas[0].height && x>=0 && x < this.canvas[0].width;
};
    Scribble.prototype.updateCanvas = function (event) {
    if(!this._enabled) {
       return;
    }
    var oldX,oldY,dX,dY,canDraw,scaleX,scaleY,cssWidth,cssHeight;
    cssWidth = parseInt(this.canvas[0].style.width,10);
    cssHeight = parseInt(this.canvas[0].style.height,10);
    scaleX =  cssWidth?this.canvas[0].width/cssWidth:1;
    scaleY = cssHeight?this.canvas[0].height/cssHeight:1;

    scaleX /= xfalib.ut.XfaUtil.prototype.formScaleFactor;
    scaleY /= xfalib.ut.XfaUtil.prototype.formScaleFactor;

    oldX = this.lastMousePoint.x*scaleX;
    oldY = this.lastMousePoint.y*scaleY;
   
    this.updateMousePosition( event );

    var newX =  this.lastMousePoint.x*scaleX;
    var newY =  this.lastMousePoint.y*scaleY;

    dX = Math.abs(newX - oldX );
    dY = Math.abs(newY - oldY );

    canDraw = ( dX > 0 || dY > 0 ) && this._isInsideCanvas(oldX,oldY) && this._isInsideCanvas(newX,newY);;

    if(canDraw){
        this.context.beginPath();
        this.context.moveTo( oldX, oldY );
        this.context.lineTo(newX, newY );
        this.context.lineWidth=this._lineWidth;
        this.context.lineCap='round';
        this.context.stroke();
		
        this._callback();
		
    }
};

Scribble.prototype.toString = function () {

    var dataString = this.canvas.get(0).toDataURL("image/png");
    //var index = dataString.indexOf( "," )+1;
    //dataString = dataString.substring( index );

    return dataString;
};
Scribble.prototype.setEnabled=function(enable){
    this._enabled=enable;
};
Scribble.prototype.clear = function () {

    var c = this.canvas[0];
    this.context.clearRect( 0, 0, c.width, c.height );
};


// ImageEdit dialog box
var imageEditDialog=(function(_){
  
    // html used to construct dialog box
    var htmlStr=(function(){
         var html=[
             '<div id="iEBox_container" tabindex="0" role="dialog" aria-label="'+ScribbleUtil.localeString("pleaseSignText")+'">',
                  '<div id="iEBox_panel">',
                      '<div  id = "iEBox_Cancel" class="iEBox_button" tabindex="0" role="button" aria-label="'+ScribbleUtil.localeString("cancel")+'" title="'+ScribbleUtil.localeString("cancel")+'" ></div>',
                  '</div>',
                  '<div id="iEBox_content">',
                      '<div id="iEBox_canvases" align=center>',
                          '<div style="display:inline-block; vertical-align:top;">',
                               '<canvas  id="iEBox_canvas" style="margin:0px;border-bottom:0px;" width="696" height="390" ></canvas>' ,
                               '<input type="text" id="keyboard_Sign_Box" name="signatureText" placeholder="'+ScribbleUtil.localeString("typeYourSignatureHere")+'">',
                               '<fieldset id="iEBox_caption"><legend align="center">'+ScribbleUtil.localeString("pleaseSignText")+'</legend></fieldset>',
                          '</div>',
                          '<canvas id="iEBox_geoCanvasRight" width="0" height="0" ></canvas>',
                          '<div><canvas id="iEBox_geoCanvasBottom" width="0" height="0" ></canvas></div>',
                      '</div>',
                      '<div>',
                          '<div id="iEBox_Brush" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("brushes")+'"  title="'+ScribbleUtil.localeString("brushes")+'"></div>',
                          '<div id="iEBox_Clear" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("clear")+'"  title="'+ScribbleUtil.localeString("clear")+'" ></div>',
                          '<div id="iEBox_Geo" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("geolocation")+'"  title="'+ScribbleUtil.localeString("geolocation")+'" ></div>',
                          '<div id="iEBox_Text" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("typeYourName")+'"  title="'+ScribbleUtil.localeString("typeYourName")+'"></div>',
                          '<div id="iEBox_title"></div>',
                          '<div id="iEBox_Ok" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("ok")+'"  title="'+ScribbleUtil.localeString("ok")+'" ></div>',
                      '</div>' ,
                  '</div>' ,
                  '<div id="iEBox_moveframe" ></div>',
                  '<div id="iEBox_brushList" ></div>',
              '</div>'].join("");
           return function(){
              return html;
           };
    });
	
    /**
	 *   
	 */
	
    var dialogObj = {
        verticalOffset: 0, // removing the magic value of -75 since it was not causing any impact
        horizontalOffset: 0,
        repositionOnResize: true,
        overlayOpacity: .75,
        overlayColor: '#CCCCCC',
        draggable: true,
        _brushes:[2,3,4,5,6,7,8,9,10],
		_buttonsEnabled:{},
		_isOpen:false,
        show:function(title,callback){
           this._show(callback);
		   this._buttonsEnabled={Geo:true,Clear:true,Ok:true,Cancel:true,Brush:true,Text:true};
        },
		setEnabled:function(button,enable){
		    if(this._buttonsEnabled[button]!=enable){
		           this._buttonsEnabled[button]=enable;
				   if(enable){
				       $('#iEBox_'+button).empty('<div style="background:white;width:100%;height:100%;opacity:0.75;"></div>').
				                  removeClass("disable_button");
				   } else {
				       $('#iEBox_'+button).append('<div style="background:white;width:100%;height:100%;opacity:0.75;"></div>').
				                  addClass("disable_button");
				   }
			       
			}
		},
		enableButtons:function(buttons){
		    for(var k in buttons){
				   this.setEnabled(k,buttons[k]);
			}
		},
        toggleBrushList:function(event){
                var that = this;
                if($('#iEBox_brushList').css('display')!='none'){
                    $('#iEBox_brushList').css({display:'none'});
                    return;
                }
                 var tmpFn =  document.onselectstart;
                 document.onselectstart=function(){return false;};
                 $('#iEBox_brushList').css({display:'block',visibility:'hidden'});
                    $('#iEBox_brushList').offset($('#iEBox_Brush').offset());
                    $('#iEBox_brushList').offset({top:$('#iEBox_Brush').offset().top-$('#iEBox_brushList').height()});
                    $('#iEBox_brushList').css({display:'block',visibility:'visible'});
                  //  $('#iEBox_brushList').focus();
                     $('#iEBox_brushList').one('mouseleave',function(event){
                         $('#iEBox_brushList').css({display:'none'});
                          document.onselectstart=tmpFn;
                     });
        },
        _attachCallbacks: function(callback) {
            var that = this;
            var sigCanvas = $('#iEBox_canvas')[0];
            var ctx=sigCanvas.getContext("2d");
            var minSigCanvasFontSize=10;
            var maxSigCanvasFontSize=70;
            var sigCanvasFontSize=minSigCanvasFontSize;
            var initialSigCanvasFontSize=sigCanvasFontSize;
            var initialFontCalculatedFlag=false;
            var sigCanvasFontFamily="sans-serif, Georgia";
            var sigCanvasFontStyle="italic";
           _.each("Cancel-Clear-Geo-Ok-Brush-Text".split("-"),function(val,idx){
                    $("#iEBox_"+val).click( function(event) {
				       if(that._buttonsEnabled[val]){
                          event.stopPropagation();
                          callback(val);
				       }
                    });
					$("#iEBox_"+val).keydown( function(event) {
				       if(that._buttonsEnabled[val] && (event.keyCode == ENTER_KEY || event.charCode == ENTER_KEY || event.which == ENTER_KEY) ){
                          event.stopPropagation();
                          callback(val);
				       }
                    });
            });
            _.each($("#iEBox_brushList").children(),function(itm,idx){
                  $(itm).on(TouchUtil.POINTER_UP,function(event){
                         callback("BrushSelect",that._brushes[idx]);
                         $('#iEBox_brushList').css({display:'none'});
                          // $(itm).css({backgroundColor:'#FFFFFF'});
                  });
                  $(itm).on(TouchUtil.POINTER_DOWN,function(event){
                          // $(itm).css({backgroundColor:'#AAAAAA'});
                           event.preventDefault();
                  });
             });

            $('#keyboard_Sign_Box').keydown(function (event){
                var inputSign=$('#keyboard_Sign_Box')[0].value;

                if(event.key==="Backspace") {
                    ctx.font=sigCanvasFontStyle+sigCanvasFontSize+"px "+sigCanvasFontFamily;
                    sigCanvasFontSize=dialogObj._increaseFontForSignature(ctx.measureText(inputSign).width,sigCanvas.width,
                        sigCanvasFontSize,initialSigCanvasFontSize);
                    ctx.font=sigCanvasFontStyle+" "+sigCanvasFontSize+"px "+sigCanvasFontFamily;
                    ctx.clearRect(0, 0, sigCanvas.width, sigCanvas.height);
                    ctx.fillText(inputSign, 3, sigCanvasFontSize, sigCanvas.width-5);
                }
                event.stopPropagation();
            });

            $("#keyboard_Sign_Box").keyup(function (event){
                var inputSign=$('#keyboard_Sign_Box')[0].value;
                if(inputSign.length==0) {
                    dialogObj.enableButtons({Ok: false, Clear: false});
                }
                if(inputSign.length>=1 && inputSign.trim().length!=0) {
                    dialogObj.enableButtons({Ok: true, Clear: true});
                }
                if(initialFontCalculatedFlag===false){
                    sigCanvasFontSize=sigCanvas.height-20;
                    sigCanvasFontSize=sigCanvasFontSize<minSigCanvasFontSize?minSigCanvasFontSize:sigCanvasFontSize;
                    sigCanvasFontSize=sigCanvasFontSize>maxSigCanvasFontSize?maxSigCanvasFontSize:sigCanvasFontSize;
                    initialSigCanvasFontSize=sigCanvasFontSize;
                    $('#keyboard_Sign_Box')[0].style.font=sigCanvasFontStyle+" 2rem "+sigCanvasFontFamily;
                    initialFontCalculatedFlag=true;
                }
                ctx.font=sigCanvasFontStyle+sigCanvasFontSize+"px "+sigCanvasFontFamily;
                sigCanvasFontSize=dialogObj._decreaseFontForSignature(ctx,inputSign,sigCanvas.width,
                    sigCanvasFontSize,sigCanvasFontFamily);
                ctx.font=sigCanvasFontStyle+" "+sigCanvasFontSize+"px "+sigCanvasFontFamily;
                ctx.clearRect(0, 0, sigCanvas.width, sigCanvas.height);
                ctx.fillText(inputSign,3,sigCanvasFontSize,sigCanvas.width-5);
                event.stopPropagation();
            });

            // capture tab key and escape
            $('#iEBox_container').keydown(function(event){
                var firstFocusableItem = document.querySelector("#iEBox_container");
                var lastFocusableItem = document.querySelector("#iEBox_Ok");
                var KEYCODE_TAB = 9;
                var isTabPressed = (event.key === 'Tab' || event.keyCode === KEYCODE_TAB);
                if((event.keyCode == ESC_KEY || event.charCode == ESC_KEY || event.which == ESC_KEY)) {
                    event.stopPropagation();
                    event.preventDefault();
                    callback("Cancel");
                } else if (isTabPressed) {
                    // Trap focus inside the dialog box
                    if (event.shiftKey && document.activeElement === firstFocusableItem) {
                        // when shift + tab key is pressed
                        lastFocusableItem.focus();
                        event.preventDefault();
                    } else if (document.activeElement === lastFocusableItem) {
                        // when tab key is pressed
                        firstFocusableItem.focus();
                        event.preventDefault();
                    }
                }

            });

            if(this.draggable){
                this._makeDraggable(TouchUtil.TOUCH_ENABLED);
            }
        },

        _decreaseFontForSignature:function(ctx,inputSign,sigCanvasWidth,fontSize,sigCanvasFontFamily){
            while(ctx.measureText(inputSign).width>sigCanvasWidth-5 && fontSize>20){
                fontSize=fontSize-10;
                ctx.font=fontSize+"px "+sigCanvasFontFamily;
            }
            return fontSize
        },
        _increaseFontForSignature:function(textWidth,sigCanvasWidth,fontSize,initialSigCanvasFontSize){
            if(sigCanvasWidth-textWidth>0){
                fontSize=initialSigCanvasFontSize;
            }
            return fontSize;
        },
        _makeDraggable:function(touchEnabled){
              var _isMouseDown=false;
              var _that=this;
              var dX;
              var dY;
              var offsetPos;
              var _mouseMovFun;
              var _mouseUpFun;
              $('#iEBox_panel').on(TouchUtil.POINTER_DOWN,function( event ){
              
                  if(TouchUtil.getTouches(event).length < 2){
                      if($(event.target).is('#iEBox_panel')){
                          $('body')[0].addEventListener(TouchUtil.POINTER_MOVE,_mouseMovFun=function( event ){
                              if(TouchUtil.getTouches(event).length < 2 && _isMouseDown){
                                  event.preventDefault();
                                  var evt = TouchUtil.getTouchEvent(event);
                                  var delX = evt.pageX - dX;
                                  var delY = evt.pageY - dY;
                                  $('#iEBox_moveframe').offset({
                                      top: offsetPos.top+delY,
                                      left: offsetPos.left+delX
                                  });
                              }
                          }, { passive: false });
                          $('body').on(TouchUtil.POINTER_UP,_mouseUpFun=function(event){
                              if(_isMouseDown){
                                  var offsetMove = $('#iEBox_moveframe').offset();
                                  var topEdge  = $(window).scrollTop();
                                  var bottomEdge = topEdge + $(window).height();
                                  if(offsetMove.top - topEdge < 1){
                                      offsetMove.top = topEdge;
                                  }
                                  if(offsetMove.top - bottomEdge + $('#iEBox_panel').height() > 0 ){
                                      offsetMove.top = bottomEdge - $('#iEBox_panel').height();
                                  }
                                  $('#iEBox_container').offset(offsetMove );
                                  $('#iEBox_moveframe').css({display:'none'}).offset(offsetMove);
                                  _isMouseDown=false;
                                  $('body')[0].removeEventListener(TouchUtil.POINTER_MOVE,_mouseMovFun,{ passive: false });
                                  $('body').off(TouchUtil.POINTER_UP,_mouseUpFun);
                              }
                          });

                          var evt = TouchUtil.getTouchEvent(event);
                          _isMouseDown=true; dX = evt.pageX;dY=evt.pageY;
                          offsetPos = $('#iEBox_container').offset();
                          $('#iEBox_moveframe').css({display:'block'});
                          $('#iEBox_moveframe').offset(offsetPos);
                          $('#iEBox_moveframe').css('width',$('#iEBox_container').css('width'));
                          $('#iEBox_moveframe').css('height',$('#iEBox_container').css('height'));
                      }
                  }
              });
             
        },
        _createBrushes:function(){
               var _that=this;
              _.each(this._brushes,function(val,idx){
                  var divel = document.createElement('DIV');
                  var cnv = document.createElement('CANVAS');
                  var ctx = cnv.getContext('2d');
                  cnv.style.border='1px solid #AAAAAA';
                  cnv.width=TouchUtil.TOUCH_ENABLED?200:100;
                  cnv.height=TouchUtil.TOUCH_ENABLED?40:20;;
                  ctx.lineWidth=val;
                  ctx.beginPath();
                  ctx.moveTo(10,cnv.height/2);
                  ctx.lineTo(cnv.width-10,cnv.height/2);
                  ctx.stroke();
                  divel.appendChild(cnv);
                  $('#iEBox_brushList').append(divel);
               });
        },
		getIsOpen:function(){
		    return dialogObj._isOpen;
		},
		setIsOpen:function(open){
		    dialogObj._isOpen = open;
		},
        _show: function(callback) {
            dialogObj.hide();
            dialogObj._overlay('show');
            
            $("BODY").append(htmlStr());
            dialogObj.setIsOpen(true);
            $('#iEBox_container').focus();
            dialogObj._createBrushes();

            dialogObj._reposition();

            // calculate spacing around canvas area
            // this will be used to find canvas dimensions based on available screen area.
            var container_el = $('#iEBox_container');
            var canvas_el =  $('#iEBox_canvas');
            var container_width = $('#iEBox_container').outerWidth(true);
            var container_height = $('#iEBox_container').outerHeight(true);
            var canvas_width = canvas_el[0].width;
            var canvas_height = canvas_el[0].height;
            dialogObj.canvas_spacing = { x:container_width - canvas_width, y:container_height-canvas_height};

            dialogObj._maintainPosition(true);
            
            dialogObj._attachCallbacks(callback);
        },

        hide: function() {
            $("#iEBox_container").remove();
            this._overlay('hide');
            dialogObj.setIsOpen(false);
            this._maintainPosition(false);
        },
        _overlayResize:function(event) {
            if($("#iEBox_overlay").height()!= $(document).height()){
                $("#iEBox_overlay").height( $(document).height() );
            }

        },
        _disableMove:function(event) {
            event.preventDefault();
        },
        _overlay: function(status) {
            switch( status ) {
                case 'show':
                    this._overlay('hide');
                    $("BODY").append('<div id="iEBox_overlay"></div>');
                    $("#iEBox_overlay").css({
                        position: 'fixed',
                        zIndex: 99997,
                        top: '0px',
                        left: '0px',
                        width: '100%',
                        height: $(document).height(),
                        background: this.overlayColor,
                        opacity: this.overlayOpacity
                    });
                    if(xfalib.ut.XfaUtil.prototype.isSafari()) {
                        $("#iEBox_overlay").on('touchmove', this._disableMove);
                    }
                    $(document).on('scroll',this._overlayResize);
                break;
                case 'hide':
                    if(xfalib.ut.XfaUtil.prototype.isSafari()) {
                        $("#iEBox_overlay").off('touchmove');
                    }
                    $("#iEBox_overlay").remove();
                    $(document).off('scroll',this._overlayResize);
                break;
            }
        },
        /**
         * resize dialog based on available screen area
         */
        _resize:function(){
            // available screen area
            var aWidth = $(window).width();
            var aHeight = $(window).height();

            var sigCnv = $('#iEBox_canvas')[0];
            var sigTextBox = $('#keyboard_Sign_Box')[0];
            var bGeoCnv = $('#iEBox_geoCanvasBottom')[0];
            var rGeoCnv = $('#iEBox_geoCanvasRight')[0];

            // calculate amount of width height we need to reduce

            var totalCnvWidth = sigCnv.width + rGeoCnv.width;
            var totalCnvHeight = sigCnv.height + bGeoCnv.height;





            var diffW = totalCnvWidth + dialogObj.canvas_spacing.x - aWidth;
            if(diffW < 0) {
                diffW = 0;
            }
            var diffH = totalCnvHeight + dialogObj.canvas_spacing.y - aHeight;
            if(diffH < 0){
                diffH = 0;
            }

            var newTotalCnvHeight, newTotalCnvWidth;
            if( diffW > 0 || diffH > 0 ){ // does any side need resize

                if(diffH * totalCnvWidth > totalCnvHeight * diffW){ // need to reduce height
                   newTotalCnvHeight = totalCnvHeight - diffH;
                   newTotalCnvWidth = (newTotalCnvHeight * totalCnvWidth)/ totalCnvHeight;
                } else {
                   newTotalCnvWidth = totalCnvWidth - diffW;
                   newTotalCnvHeight = (newTotalCnvWidth * totalCnvHeight)/ totalCnvWidth;
                }

                // distribute evenly the new dimensions


                var newSigCnvWidth   = (newTotalCnvWidth*sigCnv.width)/totalCnvWidth;
                var newSigCnvHeight = (newTotalCnvHeight*sigCnv.height)/totalCnvHeight;

                sigCnv.style.width = newSigCnvWidth + "px";
                sigCnv.style.height = newSigCnvHeight + "px";

                sigTextBox.style.width = newSigCnvWidth + "px";
                sigTextBox.style.height = newSigCnvHeight + "px";


                bGeoCnv.style.width = newSigCnvWidth +"px";
                bGeoCnv.style.height = (newTotalCnvHeight - newSigCnvHeight) +"px";

                rGeoCnv.style.width = (newTotalCnvWidth - newSigCnvWidth) +"px";
                rGeoCnv.style.height = newSigCnvHeight + "px";


                $('#iEBox_caption').width(Math.floor(newSigCnvWidth));

            } else {
                sigCnv.style.width =  sigCnv.width + "px";
                sigCnv.style.height = sigCnv.height + "px";

                sigTextBox.style.width =  sigCnv.width + "px";
                sigTextBox.style.height = sigCnv.height + "px";

                bGeoCnv.style.width =  bGeoCnv.width + "px";
                bGeoCnv.style.height = bGeoCnv.height + "px";

                rGeoCnv.style.width =  rGeoCnv.width + "px";
                rGeoCnv.style.height = rGeoCnv.height + "px";

                $('#iEBox_caption').width(sigCnv.width);

            }
        },
        _reposition: function() {
            var top = (($(window).height() * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) / 2) - ($("#iEBox_container").outerHeight() / 2)) + dialogObj.verticalOffset;
            var left = (($(window).width() * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) / 2) - ($("#iEBox_container").outerWidth() / 2)) + dialogObj.horizontalOffset;
            if( top < 0 ) top = 0;
            if( left < 0 ) left = 0;

            $("#iEBox_container").css({
                top: top + $(window).scrollTop() * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) + 'px',
                left: left + $(window).scrollLeft() * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) + 'px'
            });
            $("#iEBox_container").focus();   // scroll up to the canvas
            $("#iEBox_overlay").height( $(document).height() );
        },
        _maintainDialog:function(){
            dialogObj._resize();
            dialogObj._reposition();
        },
        _maintainPosition: function(status) {
            if(dialogObj.repositionOnResize ) {
                switch(status) {
                    case true:
                        $(window).on('orientationchange', dialogObj._maintainDialog); // also reposition if device is tilted
                    break;
                    case false:
                        $(window).off('orientationchange', dialogObj._maintainDialog);
                    break;
                }
            }
        }
        
    };
    return dialogObj;
})(window._);

/**
 * class definition for GeoLocationQueryRequest
 * encapsulated success and error handlers 
 */
function GeoLocQuery(){}
GeoLocQuery.prototype={
    init:function(success,failure){
        this._successHandler = success;
        this._errorHandler = failure;
        this._active=true;
        return this;
    },
    _handleSuccess:function(data){
        this._successHandler(data); 
    },
    _handleError:function(err){
        this._errorHandler(err);   
    },
    query:function(){
         _that=this;
         navigator.geolocation.getCurrentPosition(function(pos){
          if(_that._active){
             _that._handleSuccess(pos);
          }
          _that._active=false;
       },function(err){
          if(_that._active){
             _that._handleError(err);
          }
          _that._active=false;
       },{timeout:10000});
    },
    cancel:function(){
        _that._active=false;
    }

};
// GeoLocQuery definition ends here

/**
*
*  Base64 encode / decode
*  http://www.webtoolkit.info/
*
**/
 
var Base64 = {
 
	// private property
	_keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
 
	// public method for encoding
	encode : function (input) {
		var output = "";
		var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
		var i = 0;
 
		while (i < input.length) {
 
			chr1 = input.charCodeAt(i++);
			chr2 = input.charCodeAt(i++);
			chr3 = input.charCodeAt(i++);
 
			enc1 = chr1 >> 2;
			enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
			enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
			enc4 = chr3 & 63;
 
			if (isNaN(chr2)) {
				enc3 = enc4 = 64;
			} else if (isNaN(chr3)) {
				enc4 = 64;
			}
 
			output = output +
			this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
			this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
 
		}
 
		return output;
	},
 
	// public method for decoding
	decode : function (input) {
		var output = "";
		var chr1, chr2, chr3;
		var enc1, enc2, enc3, enc4;
		var i = 0;
 
		input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
 
		while (i < input.length) {
 
			enc1 = this._keyStr.indexOf(input.charAt(i++));
			enc2 = this._keyStr.indexOf(input.charAt(i++));
			enc3 = this._keyStr.indexOf(input.charAt(i++));
			enc4 = this._keyStr.indexOf(input.charAt(i++));
 
			chr1 = (enc1 << 2) | (enc2 >> 4);
			chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
			chr3 = ((enc3 & 3) << 6) | enc4;
 
			output = output + String.fromCharCode(chr1);
 
			if (enc3 != 64) {
				output = output + String.fromCharCode(chr2);
			}
			if (enc4 != 64) {
				output = output + String.fromCharCode(chr3);
			}
 
		}
 
		return output;
 
	}
 
	
 
};

/**
 * Utility Singleton for handling PNG Data
 */
var PNGUtil=(function(){
    var slf={
   _LC_Scribble_MetaDataKey:"LC_SCIBBLE_METADATA",
           _isPng:function(b64data){
               return  b64data && b64data.replace(/\s+/g, "").indexOf("iVBORw0KGgo") == 0;   // LC-5711 : trim any leading WhiteSpace
               // TODO :  base64 encoding may have white spaces even between the magic numbers !! Think of a better way to stop stripping white spaces repeatedly in PNGUtil, and cache the result
           },
           _update_crc:function(crc,data){
               var c = crc;
               var n;
               for(n=0;n<data.length;n++){
                  c = this._XOR(slf._crc_table[(this._XOR(c,data.charCodeAt(n))&0xff)>>>0],(c>>>8));
               }
               return c;
           },
		   _XOR:function(a,b){
		       return (a^b)>>>0;
		   },
           _U32Int2Str:function(n){
                return String.fromCharCode((n>>>24)&0xFF)+String.fromCharCode((n>>>16)&0xFF)+String.fromCharCode((n>>>8)&0xFF)+String.fromCharCode(n>>>0&0xFF);
            },
           _init_crc_table:function(){
               var c=0;
               var n,k;
               slf._crc_table=[];
               for(n=0;n<256;n++){
                   c = n;
                   for(k=0;k<8;k++){
                      if(((c&1)>>>0)>0){
                          c = slf._XOR(0xedb88320 , (c>>>1));
                      } else {
                          c = c>>>1;
                      }
                   }
                   slf._crc_table[n]=c;
                }
           },
           _CRC:function(data){
                if(!this._crc_table) this._init_crc_table();
                return this._XOR(this._update_crc(0xffffffff,data) , 0xffffffff);
          },
          _prepareTextChunk:function(content,pad){
              // pad the data appropriately                      
               var len = content.length;
               var lenStr = slf._U32Int2Str(len);
               var chunkType="tEXt";
               var checkSumStr = slf._U32Int2Str(slf._CRC(chunkType+content));
               return lenStr+chunkType+content+checkSumStr;
           },
        _start:function(str){
           slf._startTime = new Date().getTime();
           slf._startFun=str;
        },
        _end:function(){
           var str = "Time "+slf._startFun+": "+(new Date().getTime()-slf._startTime);
          //  $('BODY').append("<p>"+str+"</p><br/>");
        },
        _readU32Int:function(ctx){
            var val=0;
            var d=ctx.d;
            val=((d.charCodeAt(ctx.p++)<<24)|(d.charCodeAt(ctx.p++)<<16)|(d.charCodeAt(ctx.p++)<<8)|(d.charCodeAt(ctx.p++)))>>>0;
             return val;
        },
       _readChunkType:function(ctx){
          var d = ctx.d;
          var str = d[ctx.p++]+d[ctx.p++]+d[ctx.p++]+d[ctx.p++];
          return str;
       },
        _makeReadOnly:function(b64data){
      slf._start("_makeReadOnly");
      // assume a valid png image encoded in base64;
      var bindata = slf._atob(b64data.replace(/\s+/g, '')); // remove white spaces that might have been inserted
      var pngctx={p:0,d:bindata};
      pngctx.p+=8;// skip pngheader
      // read IHDR
      var size = slf._readU32Int(pngctx);
      slf._readChunkType(pngctx); //IHDR
      pngctx.p+=size; //Data
      slf._readU32Int(pngctx);//CRC
      var metadataChunk = slf._prepareTextChunk(slf._LC_Scribble_MetaDataKey+String.fromCharCode(0)+"true");
      var newdata = pngctx.d.substring(0,pngctx.p)+metadataChunk+pngctx.d.substring(pngctx.p);
      var ret= slf._btoa(newdata);
      slf._end();
      return ret;
   },
   _atob:function(inp){
      if(window.atob){ return atob(inp); }
	  return Base64.decode(inp);
   },
   _btoa:function(inp){
      if(window.btoa){ return btoa(inp); }
	  return Base64.encode(inp);
   },
   _isReadOnly:function(b64data){
    slf._start("_isReadOnly");
       if(slf._isPng(b64data)){
           var testStr = slf._LC_Scribble_MetaDataKey+String.fromCharCode(0)+"true";
           var bindata = slf._atob(b64data.replace(/\s+/g, '')); // strip white spaces
           var pngctx={p:0,d:bindata};
           pngctx.p+=8;// skip header
           while(pngctx.p<pngctx.d.length){
               var size = slf._readU32Int(pngctx);
               var type = slf._readChunkType(pngctx);
               if(type=="tEXt"){
                   if(pngctx.d.indexOf(testStr,pngctx.p)==pngctx.p){
                       slf._end();
                       return true;
                   }
                  
              }
              pngctx.p+=size;
              slf._readU32Int(pngctx);// 
          }// while end
       }
       slf._end();
       return false;
   }
    };
    return slf;
})();

/**
 * JQuery widget definition starts here
 */
$.widget( "xfaWidget.ScribbleImageField", $.xfaWidget.imageField, {

    _widgetName:"ScribbleImageField",
    _geoLocQuery:null,
   _emptyImageVal:null,// should be null, but for now
   _extraInfo:null,
   _defaultStatus:"&nbsp;",
   _enforceGeoLoc:!!navigator.userAgent.match(/iPad/i),
   _sigCanvasWidth:696,
   _sigCanvasHeight:390,
   _geoCanvId:null,
    _geoLocAtBottom:false,
   _geoCanvasHeight:100,
   _geoCanvasWidth:696,
   
    _is_readonly:false,
	
    options: {
        tabIndex: 0,
        "role": "img"
    },

    getOptionsMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "displayValue": function(val) {
                if(this.options.commitProperty) {
                    if(!val){
                        this._displayValue(this._extractData(this._createEmptyImageData()));
                        this.$userControl.addClass("emptyScribble");
                        this._is_readonly=false;
                    } else {
                        this.$userControl.removeClass("emptyScribble");
                        if(PNGUtil._isPng(val)){
                            var widgetValue = "data:image/png;base64,"+this.options.value;
                        }else {
                            var widgetValue = "data:;base64," + this.options.value;
                        }
                        this._setValue(widgetValue);
                    }
                }
            }
        })
    },

    getEventMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "scribblefocus":xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
            "click":null,
            "scribbleclick":xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT,
            "change":null,
            "scribblechange":xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
            "blur":null,
            "scribbleclose":xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT
        })
    },

	/**
	 * This function achieves following
	 * 1. Calculate dimensions of canvases to be used
	 * 2. Findout if right or bottom canvas is to be used for geo location
	 */

	 aspectRatioToBeUsed :function(){
        var aspectRatio ;
        if(this.options.aspectRatio && parseFloat(this.options.aspectRatio) > 0){
           aspectRatio = 1/parseFloat(this.options.aspectRatio);  //--in MF ratio is computed as height/width instead of width/height
        } else {
           var imgEl = this.element.children("img"),
               width = imgEl.attr('width'),
               height = imgEl.attr('height'),
               fieldWidth,
               fieldHeight;

           if(width){
              fieldWidth = parseInt(width,10);
           } else {
              fieldWidth = imgEl.width();
           }
           if(height){
              fieldHeight = parseInt(height,10);
           } else {
              fieldHeight = imgEl.height();
           }
           aspectRatio = fieldHeight/fieldWidth;
        }
	    return aspectRatio;
	 },

    _setUpCanvas:function(){
        var aspectRatio ;
		aspectRatio = this.aspectRatioToBeUsed();
       
        // max width, height of generated image
        var maxWidth = 640;
        var maxHeight = 480;
        
        // width of field scaled to fit max image size
        var scaledWidth;
        var scaledHeight;
        
        
		// approx pixels required for rendering geo loc info in 12pt Arial font 
		var approxGeoLocWidth=250;
		var approxGeoLocHeight=84;
        
        scaledWidth = maxWidth;
        scaledHeight = maxWidth*aspectRatio;
        if(scaledHeight>maxHeight){
            scaledHeight = maxHeight;
            scaledWidth = maxHeight/aspectRatio;
        }
        
        // set canvas dimensions
        if(aspectRatio>=1){
			this._geoCanvId='iEBox_geoCanvasBottom';
            this._geoLocAtBottom=true;
          
			
             this._geoCanvasWidth = scaledWidth;
			 // limit height to 30% of full height;
			 this._geoCanvasHeight=Math.min(approxGeoLocHeight,scaledHeight/3);
             this._sigCanvasWidth = scaledWidth;
             this._sigCanvasHeight= scaledHeight-(this._enforceGeoLoc?this._geoCanvasHeight:0);
        } else {
			this._geoCanvId='iEBox_geoCanvasRight';
            this._geoLocAtBottom=false;
           
			
            this._geoCanvasHeight = scaledHeight;
			// limit width to 30% of full width;
			this._geoCanvasWidth=Math.min(approxGeoLocWidth,scaledWidth/3);
            this._sigCanvasHeight= scaledHeight;
            this._sigCanvasWidth= scaledWidth-(this._enforceGeoLoc?this._geoCanvasWidth:0);
        }
       
    },

   render : function() {
       var geoLocMandatoryOnIpad = this.options.geoLocMandatoryOnIpad;
       if(typeof(geoLocMandatoryOnIpad)!="undefined"){
           this._enforceGeoLoc= this._enforceGeoLoc && (/^(true|1)$/i).test($.trim(geoLocMandatoryOnIpad));
       }
       this._wgtId="wid"+~~(Math.random()*2000)+"_"+new Date().getTime();

       var $control = $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments)

       if(this.options.value || this.options.value != this._emptyImageVal){
          this._is_readonly=!!PNGUtil._isReadOnly(this.options.value);
       }
   
       if(this._is_readonly){
          $control.after("<div id='"+this._wgtId+"' class='sc_popUpMenu'></div>");
       } else {
          $control.after("<div id='"+this._wgtId+"' style='display:none;' class='sc_popUpMenu'></div>");
       }
	   
	   this._setUpCanvas();
       return $control;
    },

   click: function() {
        this.focus();
        var tmpEl = this.element.length?this.element[0]:this.element;
        if(this.options.access != "open")
          return;
       if (TouchUtil.POINTER_ENABLED || TouchUtil.TOUCH_ENABLED) {
           // simulate a click event
           tmpEl.dispatchEvent(TouchUtil.getPointerEvent(TouchUtil.POINTER_DOWN));
           tmpEl.dispatchEvent(TouchUtil.getPointerEvent(TouchUtil.POINTER_UP));
        }
        else {
              this.$userControl.triggerHandler("click");
        }
   },

    _attachEventHandlers:function($control){
	     if(TouchUtil.POINTER_ENABLED || TouchUtil.TOUCH_ENABLED){
            this._attachTouchEventHandlers($control);
         } else {
            this._attachMouseEventHandlers($control);
         }
         $control.keydown($.proxy(this._handleKeyDown,this));
    },
	_attachEventHandlerForCrossIcon:function($control){
	    var _that = this;
	    $control.mouseenter(function(event){
             if(_that.options.access != "open")
                    return;
             event.stopPropagation();
             if(_that._is_readonly){
                $('#'+_that._wgtId).css({display:'block'});
                var bodyMoveHandler;
                $('body').on('mousemove',bodyMoveHandler=function(event){
                    if(event.target!=$('#'+_that._wgtId)[0]&&event.target!=_that.$userControl[0]){
                        $('#'+_that._wgtId).css({display:'none'});
                         $('body').off('mousemove',bodyMoveHandler);
                    }
                });
              }
       });

       setTimeout(function(){ $("#"+_that._wgtId).click($.proxy(_that._onCrossClick,_that));},50);  
	},
    _attachTouchEventHandlers:function($control){
        var _timer,_that=this;
        var tmpEl = this.element.length?this.element[0]:this.element;
       tmpEl.addEventListener(TouchUtil.POINTER_DOWN,function(event){
           if(_that.options.access != "open")
              return;
             event.preventDefault();
           _timer = setTimeout(function(){
                _timer=0;
               _that._onCrossClick(event);
            },1000);
        });
       tmpEl.addEventListener(TouchUtil.POINTER_UP,function(event){
            if(_that.options.access != "open")
                return;
            event.preventDefault();
            if(_timer){
               clearTimeout(_timer);
               _that._onImageClick(event);
            } 
        });
		
	   if(TouchUtil.POINTER_ENABLED){
		     this._attachEventHandlerForCrossIcon($control);
			 setTimeout(function(){ $("#"+_that._wgtId).on(TouchUtil.POINTER_UP,function(event){
			        event.stopPropagation();
			 });},50);
	   }
    },

    _attachMouseEventHandlers:function($control){
         var _timer=0,_that=this,_hoverTimer=0;
        $control.dblclick(function(event){
            if(_that.options.access != "open")
                return;
           event.preventDefault();event.stopPropagation();
           if(_timer.val){
             clearTimeout(_timer);_timer =0;
           }
           _that._onCrossClick(event);
        }).click(function(event){
           _that.$userControl.trigger("scribbleclick",event);
           if(_that.options.access != "open")
                return;
           event.preventDefault();
           event.stopPropagation();
           if(_timer){
              clearTimeout(_timer);_timer=0;
            } else {
              _timer = setTimeout(function(){
                 _timer=0;
                 _that._onImageClick(event);
              },500);
            }
       });
	   
	   this._attachEventHandlerForCrossIcon($control);
       
    },

    _onCrossClick:function(event){
        if(!this._is_readonly) return;
        this.$userControl.trigger("scribblefocus",event);
        this.$userControl.trigger("scribbleclick",event);
        event.stopPropagation();
        $.alertBox.yesNo(null,
         this.localeStrings().clearSignatureConfirm,
         this.localeStrings().clearSignature,
         $.proxy(this._removeSigConfirmationHandler,this));
     },

     _removeSigConfirmationHandler:function(isYes){
        if(isYes){
           this._saveValue(this._emptyImageVal);
           this._displayValue(this._extractData(this._createEmptyImageData()));
           this.$userControl.addClass("emptyScribble").trigger("scribbleclose",{});
           this._is_readonly=false;
        }
     },

    _createEmptyImageData:function(){
         if(!this._emptyImageData){
            var emptyCanvasObj = document.createElement('canvas');
            emptyCanvasObj.style.width=this._sigCanvasWidth+'px';
            emptyCanvasObj.style.height=this._sigCanvasHeight+'px';
            emptyCanvasObj.width=this._sigCanvasWidth;
            emptyCanvasObj.height=this._sigCanvasHeight;
            var ctx = emptyCanvasObj.getContext('2d');
            ctx.fillStyle='#ffffff';
            ctx.clearRect(0,0,this._sigCanvasWidth,this._sigCanvasHeight);
            this._emptyImageData = emptyCanvasObj.toDataURL("image/png");
         }
         return this._emptyImageData;
     },

    getCommitValue: function() {
        return this.options.value
    },

    _saveValue:function(val){
        this.options.value=val;
        this.$userControl.trigger('scribblechange');
    },

    _displayValue:function(val){
        if(this.options.commitProperty) {
            //hardcode the widget VALUE by unknown image type
            if(val){
              var widgetValue = "data:image/png;base64,"+val;
                this._setValue(widgetValue);
            }
        }
        else
            this.logger().debug("xfaView","[DefaultWidget._update], User Control or Commit Property is null" );
    },

    _doOk:function(){
        var mainCanvas = document.createElement('CANVAS');
        var geoCnv = $('#'+this._geoCanvId)[0];
        var sigCnv = $('#iEBox_canvas')[0];
        var ctx = mainCanvas.getContext('2d');
       
        if(geoCnv.width>0&&geoCnv.height>0){
            
            if(this._geoLocAtBottom){
                mainCanvas.width=sigCnv.width;
                mainCanvas.height =sigCnv.height+geoCnv.height;
                ctx.drawImage(sigCnv,0,0);
                ctx.drawImage(geoCnv,0,sigCnv.height);
            } else {
                mainCanvas.width=sigCnv.width+geoCnv.width;
                mainCanvas.height =sigCnv.height;
                ctx.drawImage(sigCnv,0,0);
                ctx.drawImage(geoCnv,sigCnv.width,0);
            }
        } else {
             mainCanvas.width=sigCnv.width;
             mainCanvas.height =sigCnv.height;
             ctx.drawImage(sigCnv,0,0);
        }
        imageEditDialog.hide();
        var newdata = mainCanvas.toDataURL("image/png");//(this.myScribbleHandle||"").toString();
        
         var val,val1;
         if((val=/*=*/this._extractData(newdata))){
         //  val1 = PNGUtil._makeReadOnly(val);
            val = PNGUtil._makeReadOnly(val);
            this._saveValue(val);   
            this._is_readonly=true;       
          }
          this._geoLocQuery&&this._geoLocQuery.cancel();// cancel current geo loc request;
        this.$userControl.trigger("scribbleclose")
    },
    _handleOk:function(){
        if(this._enforceGeoLoc){
           this._geoLocQuery = new GeoLocQuery().init($.proxy(function(data){
               this._geoQuerySuccessHandler(data);
               this._doOk();
           },this),$.proxy(this._geoQueryErrorHandler,this));
           this._geoLocQuery.query();
           this._showMessage(this.localeStrings().fetchGeoLocation);
        } else {
          this._doOk();
        }
    },

    _handleCancel:function(){
         imageEditDialog.hide();
         this._geoLocQuery&&this._geoLocQuery.cancel();// cancel current geo loc request;
        this.$userControl.trigger("scribbleclose")
    },

    _handleClear:function(){
        this.myScribbleHandle.setEnabled(true);
        this._is_readonly=false;
        this._makeReadOnly(this._is_readonly);
        $('#iEBox_canvas')[0].width=this._sigCanvasWidth;
         $('#iEBox_caption').width(this._sigCanvasWidth);
		$('#iEBox_canvas')[0].height=this._sigCanvasHeight;
        $('#keyboard_Sign_Box')[0].value="";
        var geoCanv = $('#'+this._geoCanvId)[0];
        imageEditDialog.enableButtons({Ok:false,Clear:false});
        geoCanv.width=0;
        geoCanv.height=0;
        imageEditDialog._resize();
        this._geoLocQuery&&this._geoLocQuery.cancel();// cancel current geo loc request;
    },
    _makeReadOnly:function(readonly){
       imageEditDialog.enableButtons({Ok:false,Clear:false,Geo:!readonly,Brush:!readonly,Text:!readonly});
       if(readonly){
		   $('#iEBox_canvas').css({border:'1px solid gray'});
           $('#iEBox_caption').css({display:'none'});

       }
       this._defaultStatus = "&nbsp;";
       this._showMessage(this._defaultStatus);
    },

    _showMessage:function(msg){
        var _that = this;
        if(this._msgTimeout) { clearTimeout(this._msgTimeout); this._msgTimeout=0; }
         $("#iEBox_title").replaceWith('<div id="iEBox_title">'+msg+'</div>');
         this._msgTimeout = window.setTimeout(function(){
             $("#iEBox_title").replaceWith('<div id="iEBox_title">'+_that._defaultStatus+'</div>');
         },15000);
    },

    _geoQueryErrorHandler:function(err){
        this._showMessage(this.localeStrings().errorFetchGeoLocation);
    },

	_getLogMessage:function(key){
		     return this.logMsgs()[key]||key;
	},

    _handleGeo:function(){
          // initiate geolocation 
       if(navigator.geolocation){
           this._geoLocQuery = new GeoLocQuery().init($.proxy(this._geoQuerySuccessHandler,this),$.proxy(this._geoQueryErrorHandler,this));
           this._geoLocQuery.query();
           this._showMessage(this.localeStrings().fetchGeoLocation);
       } else {
           this.logger().debug("xfaView",this._getLogMessage("ALC-FRM-901-011"));
       }
    },

    // This Function is used to fetch the geolocation.
    calculateGeolocation: function(){
      this._handleGeo();
    },

    _handleText:function(){
        var signBoxEl=document.getElementById("keyboard_Sign_Box");
        var signCanvasEl=document.getElementById("iEBox_canvas");
        if(signBoxEl.value.length==0){
            this._handleClear();
        }
        this._disableSignatureCanvas();
        this._enableSignatureTextBox();
        signBoxEl.focus();
    },

    _disableSignatureTextBox:function(){
        document.getElementById("keyboard_Sign_Box").style.display = "none";
    },

    _enableSignatureTextBox:function(){
        document.getElementById("keyboard_Sign_Box").style.display = "inline-block";
    },

    _disableSignatureCanvas:function(){
        document.getElementById("iEBox_canvas").style.display = "none";
    },

    _enableSignatureCanvas:function(){
        document.getElementById("iEBox_canvas").style.display = "inline-block";
    },

    _handleBrushSelect:function(w){
        if(this.myScribbleHandle&&!this._is_readonly) {
            this.myScribbleHandle.setLineWidth(w);
        }
    },

    _handleBrush:function(evt){
        if($('#keyboard_Sign_Box')[0].value.length>0){
            this._handleClear();
        }
        this._disableSignatureTextBox();
        this._enableSignatureCanvas();
        imageEditDialog.toggleBrushList(evt);
    },
	_handleKeyDown:function(event){
		if(event.keyCode == ENTER_KEY || event.charCode == ENTER_KEY || event.which == ENTER_KEY) { // touch devices may return charCode
		    event.preventDefault();
		    this._onImageClick(event);
		} else if(event.keyCode == DELETE_KEY || event.charCode == DELETE_KEY || event.which == DELETE_KEY) {
		    this._onCrossClick(event);
		}
    },
    _dialogCallback:function(button_val,arg1){
           // add back on click handler
         //  this.$userControl.click($.proxy(this._onImageClick, this));
                     
           switch(button_val){
               case "Ok":
               this._handleOk();
               break;
               case "Cancel":
               this._handleCancel();
               break;
               case "Clear":
               this._handleClear();
               break;
               case "Geo":
               this.calculateGeolocation();
               break;
               case "BrushSelect":
               this._handleBrushSelect(arg1);
               break;
               case "Brush":
               this._handleBrush(arg1);
               break;
               case "Text":
               this._handleText();
               break;
              
           }
    },

    _geoQuerySuccessHandler:function(data){
        this._renderPosition(data);
    },

	_fitGeoLocText:function(latStr,longStr,timeStr,ctx,maxWidth,maxHeight){
	    var fontSize=12;
		ctx.font="bold "+fontSize+"pt Arial";
		var width = Math.max(ctx.measureText(latStr).width,ctx.measureText(longStr).width,ctx.measureText(timeStr).width);
		var lineHeight = ctx.measureText("m").width*1.5;
		while((width>maxWidth||3*lineHeight>maxHeight)&&fontSize>1){
		    fontSize--;
		    ctx.font="bold "+fontSize+"pt Arial";
		    width = Math.max(ctx.measureText(latStr).width,ctx.measureText(longStr).width,ctx.measureText(timeStr).width);
		    lineHeight = ctx.measureText("m").width*1.5;
		}
		return {width:width,lineHeight:lineHeight,fontSize:fontSize};
	},

    _renderPosition:function(position){
        if(position&&position.coords){
         this._showMessage("&nbsp;");
            var latStr = this.localeStrings().latitude+": " + position.coords.latitude;
            var longStr = this.localeStrings().longitude+": " + position.coords.longitude;
            var dateObj = new Date();
            var tZone = (dateObj.getTimezoneOffset()/60*-1);
            
            var timeStr = this.localeStrings().time+": "+(dateObj.getMonth()+1)+"/"+dateObj.getDate()+"/"+dateObj.getFullYear()+" "+dateObj.getHours()+":"+dateObj.getMinutes()+":"+dateObj.getSeconds()+((tZone>0)?" +":" ")+(tZone);
            var canvasObj  = $('#'+this._geoCanvId)[0];
			var sigCanvas = $('#iEBox_canvas')[0];
            var sigTextBox = $('#keyboard_Sign_Box')[0];
			var dummyCanvas = document.createElement('canvas');
            if(canvasObj){
			   var ctx = canvasObj.getContext('2d');
			   ctx.font="bold 12pt Arial";

			   canvasObj.width=this._geoCanvasWidth;
               canvasObj.height=this._geoCanvasHeight;
			   var layout = this._fitGeoLocText(latStr,longStr,timeStr,ctx,canvasObj.width,canvasObj.height);
               var aspectRatio ;
     		   aspectRatio = this.aspectRatioToBeUsed();
			   if(!this._enforceGeoLoc){
			       if(this._geoLocAtBottom){
                     dummyCanvas.height = this._sigCanvasHeight-canvasObj.height;
                     dummyCanvas.width = dummyCanvas.height/aspectRatio;
                   } else {
                     dummyCanvas.width = this._sigCanvasWidth-canvasObj.width;
					 dummyCanvas.height = dummyCanvas.width*aspectRatio;
				   }
				   // move drawn signature to a temporary canvas and scale it to new dimension
                   dummyCanvas.getContext('2d').drawImage(sigCanvas,0,0,dummyCanvas.width,dummyCanvas.height);
                   if(this._geoLocAtBottom){
                     sigCanvas.height = dummyCanvas.height;
                     sigTextBox.height = dummyCanvas.height;
                     sigCanvas.getContext('2d').drawImage(dummyCanvas,(sigCanvas.width-dummyCanvas.width)/2,0);
                   } else {
                     sigCanvas.width = dummyCanvas.width;
                     sigTextBox.width = dummyCanvas.width;
                     sigCanvas.getContext('2d').drawImage(dummyCanvas,0,(sigCanvas.height-dummyCanvas.height)/2);
                   }
                   $('#iEBox_caption').width(sigCanvas.width);
				   imageEditDialog.enableButtons({Clear:true});
			   }
			      
			   var fwidth = layout.width;
               var fheight = layout.lineHeight;
			   var bottomMargin=2;
               ctx.fillStyle='#555555';
               ctx.font="bold "+layout.fontSize+"pt Arial";
               ctx.fillText(latStr,0,canvasObj.height-2*fheight-bottomMargin);
               ctx.fillText(longStr,0,canvasObj.height-fheight-bottomMargin);
               ctx.fillText(timeStr,0,canvasObj.height-bottomMargin);
			   
			   imageEditDialog._resize();
            }
        }
    },
    _scribbleCallback:function(){
       imageEditDialog.enableButtons({Clear:true,Ok:true});  //  enable clear and ok buttons
    },
    _onImageClick:function(){
       if(!imageEditDialog.getIsOpen()){
           var _that = this;
           imageEditDialog.show("&nbsp;",$.proxy(this._dialogCallback, this));
           if(!this._enforceGeoLoc){
               $('#iEBox_Geo').css({display:'inline-block'});
           }
           var image = new Image();
           image.onload=function(){
               _that.myScribbleHandle = new Scribble("iEBox_canvas",image,image.width,image.height,$.proxy(_that._scribbleCallback,_that));
               _that.myScribbleHandle.setEnabled(!_that._is_readonly);
               $('#iEBox_caption').width(image.width);
               $('#iEBox_container').css({display:'table'});
               if($('#iEBox_container').length == 1){
                   $('#iEBox_container')[0].focus();
               }
               imageEditDialog._resize();
               imageEditDialog._reposition();      // recalculate position, so that the values are updated, esp. in iPad
           }
           if(!this.options.value||this.options.value==this._emptyImageVal){
               this._is_readonly=false;
               this.$userControl.addClass("emptyScribble");
               image.src = this._createEmptyImageData();
           } else {
               this.$userControl.removeClass("emptyScribble");
               if(PNGUtil._isPng(this.options.value)){
                   this._is_readonly = !!PNGUtil._isReadOnly(this.options.value);
			       image.src = "data:image/png;base64,"+this.options.value;//this.createBl _that.$userControl.attr(_that.options.commitProperty);
               } else {
                   image.src = "data:;base64," + this.options.value;//this.createBl _that.$userControl.attr(_that.options.commitProperty);
		       }
           }
           this._makeReadOnly(this._is_readonly);
       }
    },

    _extractData:function(datauri){
        var idx;
        if(datauri!=null&&datauri.length>0&&datauri.indexOf("data:")==0){
            if((idx=datauri.indexOf(","))>0){
                return datauri.substr(idx+1);
            }
        }
    },

    _setValue:function(val){
        this.$userControl.prop(this.options.commitProperty, val);
        this.$userControl.attr(this.options.commitProperty, val);
        if(this._dummyImg){
            this._dummyImg.setAttribute(this.options.commitProperty,val);
        }
    }
});
 //hack for IOS5 touch bug
  $(function(){
         $('body').on('touchstart', function(e) {});
  });
  
})($,xfalib);
(function ($, window, _) {

    var _defaults = {
        placeHolderText : "Enter comments here"
    };

    var AdobeFileAttachment = function (element, options) {
        this.options = options;
        this.$elementFileUploadBtn = [];
        this.$elementFileList = [];
        this.$element = $(element);
        if (this.$element.attr("multiple") && !xfalib.ut.Utilities._isDataContainerSupported()) {
            // remove multiple attribute if multi file selection in one go is not supported
            this.$element.removeAttr("multiple");
        }
        this.$parent = this.$element.parent();
        this.invalidFeature = {
            "SIZE":1,
            "NAME":2,
            "MIMETYPE":3
        };
        Object.freeze(this.invalidFeature);
        // initialize the regex initially
        this.regexMimeTypeList  = this.options.mimeType.map(function (value, i) {
            try {
                return new RegExp(value.trim());
            } catch (e) {
                // failure during regex parsing, don't return anything specific to this value since the value contains
                // incorrect regex string
                if(window.console) {
                    console.log(e);
                }
            }
        });
    };

    var isBrowserIE9OrIE10 = ($.browser.msie && ($.browser.version === '9.0' || $.browser.version === '10.0')),
        fileLabelsCount = 0;


    AdobeFileAttachment.prototype = {
        _fileIframeName : "guide-fu-iframe",
        _addFile : "Add File",

        clear: function () {
            this.$element.val('');
            this.$elementFileList.empty();
        },

        destroy: function () {
            this.$fileDomElements = $.map(this.$fileDomElements, function(item){
                // since item can be null or object, doing this check
                if(_.isObject(item) && item.val().length === 0) {
                    //TODO: remove item from dom, since there is a memory leak
                    return item;
                }
            });
            this.values = [];
            if(isBrowserIE9OrIE10){
                if(_.last(this.$fileDomElements) == null){
                    this.cloneFileInputAndUpdateIdForIE9();
                } else {
                    this.updateLabelForAttr(_.last(this.$fileDomElements).attr("id"));
                }
            }
            this.$element.trigger("change.fileupload");
        },

        _setUrl : function(url, index){
            this.$elementFileList.find("span.guide-fu-fileName").eq(index).data("key", url);
        },

        _getUrl : function(index) {
            return this.$elementFileList.find("span.guide-fu-fileName").eq(index).data("key");
        },
        getSetFilePathAndReturnNamePathMap: function(valueList) {

            var mapOfObjectsHavingTempPathAndFileNames = {},
                $temp,
                tempPath;

            $.each(this.$elementFileList.children(), function ( index, childLiElement) {
                $temp = $(childLiElement).find("span.guide-fu-fileName");
                tempPath = $temp.data("key");
                if(!tempPath && valueList && valueList[index]) {
                    $temp.data("key", valueList[index]);
                }
                mapOfObjectsHavingTempPathAndFileNames[$temp.html()] = tempPath || $temp.data("key");
            });
            return mapOfObjectsHavingTempPathAndFileNames;
        },


        value : function(value) {
            if(!_.isUndefined(value)) {
                var _self = this,
                    comments = this.comment(),
                    isChange = false,
                    fileNames = _.isArray(this.options.fileNames) ? this.options.fileNames : null,
                    oldUrls = {};
                // Cache the url before deletion
                this.$elementFileList.children().find("span.guide-fu-fileName").each(function(){
                    var url = $(this).data("key");
                    if(!_.isUndefined(url)){
                        var fileName = url.substring(url.lastIndexOf("/") + 1);
                        oldUrls[fileName] = url;
                    }
                });
                this.$elementFileList.empty();
                if(value != null) {
                    var arr = value.split("\n");
                    // contruct initial file name and value map
                    // this is done only once in entire live cycle, its done here, since we get value here
                    if (fileNames && _.isEmpty(this._initialFileValueFileNameMap)) {
                        for (var index = 0; index < fileNames.length; index++) {
                            _self._initialFileValueFileNameMap[arr[index]] = fileNames[index]
                        }
                    }
                    // Update the value array with the file
                    this.values = _.map(arr, function(fileName, index){
                        // Check if file Name is a path, if yes get the last part after "/"
                        var slash = fileName.lastIndexOf("/"),
                            fileUrl = fileName,
                            fileUploadUrl = null;
                        if(slash !== -1) {
                            // Store the cached url here
                            fileUrl = fileUploadUrl = fileName;
                            fileName = fileName.substring(slash + 1);
                            // case: when you click on save second time
                            if((_.isObject(_self.$fileDomElements[index]) && _self.$fileDomElements[index].val().length > 0) || _.isString(_self.$fileDomElements[index])){
                                isChange = true;
                                _self.$fileDomElements[index] = null;
                            } else if(_self.$fileDomElements[index] !== null) { // create a dummy file dom for the cached value
                                 isChange = true;
                                _self.$fileDomElements.splice(index, 0, null);
                            }
                        } else if (oldUrls[fileName]) {
                            fileUploadUrl = oldUrls[fileName];
                        }
                        // if fileNames options is explicitly passed, use it
                        if (fileNames && _self._initialFileValueFileNameMap[fileUrl]) {
                            fileName = _self._initialFileValueFileNameMap[fileUrl];
                        }
                        _self.showFileList(fileName, comments[index], fileUploadUrl);
                        return fileUrl;
                    });
                    if(isChange){
                        this.$element.trigger("change.fileupload");
                    }
                } else {
                    if(_.isArray(this.values) && this.values.length !== 0){
                        this.destroy();
                    }
                }
            }
            else {
                return this.values;
            }
        },

        fileAttachment: function(){
            return this.values;
        },

        comment : function(value){
            var _self = this,
                $elem = null,
                comments;
            if (!_.isUndefined(value)) {
                if(value != null) {
                    comments = value.split("\n");
                    $elem = this.$elementFileList.find('div.guide-fu-comment');
                    $elem.each(function(index){
                        $(this).text(comments[index]);
                    });
                }
            }
            else {
                $elem = this.$elementFileList.find('div.guide-fu-comment');
                comments = [];
                $elem.each(function(){
                    comments.push($(this).text());
                });
                return comments;
            }
        },

        multiSelect : function(value){
            if(value !== undefined)
                this.options.multiSelect = value;
            else
                return this.options.multiSelect;
        },

        fileSizeLimit : function(value){
            if(value !== undefined)
                this.options.fileSizeLimit = value;
            else
                return this.options.fileSizeLimit;
        },

        mimeType : function(value){
            if(value !== undefined)
                this.options.mimeType = value;
            else
                return this.options.mimeType;
        },

        access : function(value){
            if(value == "readOnly") {
                this.$element.attr("disabled", "disabled");
                //for readOnly hide the delete icon in file list
                $(this.$parent).addClass('guide-fu-disabled');
            }
            else if(value == "open") {
                this.$element.removeAttr("disabled");
                $(this.$parent).removeClass('guide-fu-disabled');
            }
        },

        fileList : function(value) {
            var filtered,
                _self = this;
            if(value !== undefined){
                this.$fileDomElements = [];
                _.each(value, function(item, index){
                    if((_.isObject(item) && (isBrowserIE9OrIE10 || item.val().length > 0)) || (_.isString(item))){
                         // check if index is within the length
                         // this is written for delete case
                         // if item is a string, then it should be set null
                         if(_.isString(item)){
                             item = null;
                         }
                         _self.$fileDomElements[index] = item;
                    }
                });
                filtered = this.$fileDomElements;
                // In case of IE9, get the last element of fileDom and update the id for label
                if(isBrowserIE9OrIE10 && value !== null){
                    // Case: if it is single select, and then we do a restore and then after attaching another file we click save
                    if(_.last(this.$fileDomElements) == null){
                        this.cloneFileInputAndUpdateIdForIE9();
                    } else {
                        this.updateLabelForAttr(_.last(this.$fileDomElements).attr("id"));
                    }
                }
            }
            else {
                // here filtered is a new array
                // A new array is returned over here so that the user of this API doesn't try to change the widget array directly
                filtered = $.map(this.$fileDomElements, function(item, index){
                    if(!item) {
                        return _self._getUrl(index);
                    } else if((item[0].files && item[0].files.length !== 0)
                            || (_self.options.multiSelect || item[0].value.length > 0)) {
                        return item;
                    }
                });
            }
            return filtered;
        },

        // file preview html
        fileItemPreview: function(){
            return $("<span></span>").addClass("guide-fu-filePreview glyphicon glyphicon-ok");
        },

        // force flag indicates that forcefully set the dom but don't update the options
        buttonText: function (value, force) {
            if (value !== undefined) {
                if(!force)
                    this.options.buttonText = value;
                this.$elementFileUploadBtn.find('span.guide-fu-label').html(value);
            } else {
                return this.options.buttonText;
            }
        },

        // To change the icon of the button, the user should customize the class
        btnIcon: function () {
            return $("<span></span>").addClass("guide-fu-icon glyphicon glyphicon-folder-open");
        },

        btnLabel: function(){
            return $("<span></span>").addClass("guide-fu-label").html(this.options.buttonText);
        },

        fileItemList: function(){
            return this.$parent.find(this.options.fileItemListClass);
        },

        getNewCommentElementSummary : function(text){
            return $("<div title='Click to edit' tabindex='0'></p>").addClass("guide-fu-comment").text(text || _defaults.placeHolderText);
        },

        getNewCommentElement : function(text){
            return $("<div contenteditable='true' tabindex='0'></div>").addClass("guide-fu-comment").text(text || "");
        },

        fileItem: function(fileName, comment, fileUrl){
            var $fileItem = $("<li></li>").addClass("guide-fu-fileItem");
            var nameWithoutMarker = xfalib.ut.Utilities._getNameWithoutMarker(fileName);
            var $elem = $("<span tabindex='0'></span>").addClass("guide-fu-fileName").attr("aria-label", nameWithoutMarker).text(nameWithoutMarker).appendTo($fileItem).keypress(function(e) {
                if (e.keyCode === 13 || e.charCode === 32) {
                    $(e.target).click();
                }
            }).click($.proxy(this.handleFilePreview, this));
            if(this.options.disablePreview) {
               $elem.addClass('non-preview-fileName');
            }
            if(fileUrl != null){
                $elem.attr("data-key", fileUrl);
            }
            $("<span tabindex='0'></span>").addClass("guide-fu-fileClose close").attr("role", "button").attr("aria-label", xfalib.locale.Strings.FileCloseAccessText + nameWithoutMarker).text("x").appendTo($fileItem).keypress(function(e) {
                if (e.keyCode === 13 || e.charCode === 32) {
                    $(e.target).click();
                }
            })
                .click($.proxy(this.handleClick, this));

            this.fileItemPreview().appendTo($fileItem);

            if(this.options.showComment){
                this.getNewCommentElementSummary(comment).appendTo($fileItem).focus($.proxy(this.handleCommentClick, this)).click($.proxy(this.handleCommentClick, this));
            }
            return $fileItem;
        },

        toggleFileUploadBtn: function(){
            if(this.options.multiSelect) {
                // Change the look of file upload button
                if(this.$elementFileList.children().length > 0){
                    // Change the text
                    this.buttonText(this._addFile, true);
                    // Change the icon too
                    this.$elementFileUploadBtn.find('span.guide-fu-icon').removeClass("glyphicon-folder-open").addClass("glyphicon-plus");
                } else {
                    this.buttonText(this.options.buttonText);
                    this.$elementFileUploadBtn.find('span.guide-fu-icon').removeClass("glyphicon-plus").addClass("glyphicon-folder-open");
                }
            }
        },

        showInvalidMessage: function(fileName, invalidFeature){
            var that = this;
            var IS_IPAD = navigator.userAgent.match(/iPad/i) !== null,
                IS_IPHONE = (navigator.userAgent.match(/iPhone/i) !== null);
            if(IS_IPAD || IS_IPHONE){
                setTimeout(function() {
                  that.invalidMessage(that,fileName, invalidFeature);
                }, 0);
            }
            else {
               this.invalidMessage(this,fileName, invalidFeature);
            }
        },

        invalidMessage: function(refObj,fileName, invalidFeature){
            if(invalidFeature === refObj.invalidFeature.SIZE) {
                alert(xfalib.ut.LocalizationUtil.prototype.getLocalizedMessage("", xfalib.locale.Strings["FileSizeGreater"], [fileName, refObj.options.fileSizeLimit]));
            } else if (invalidFeature === refObj.invalidFeature.NAME) {
                alert(xfalib.ut.LocalizationUtil.prototype.getLocalizedMessage("", xfalib.locale.Strings["FileNameInvalid"], [fileName]));
            } else if (invalidFeature === refObj.invalidFeature.MIMETYPE) {
                alert(xfalib.ut.LocalizationUtil.prototype.getLocalizedMessage("", xfalib.locale.Strings["FileMimeTypeInvalid"], [fileName]));
            }
        },

        /***
         * Finds the value in the array, if the value is a url then it uses the filename in the url to search for the text
         * This is done since our model stores the URL too in case of draft restore or clicking on save in guide
         * @param text          string representing the text of which the index is to be found
         * @param $elem         reference to the jquery element. This is used if there are duplicate file names present in the file upload.
         * @returns {number}
         * @private
         */
        _getIndexOfText : function(text, $elem){
            var index = -1,
                self = this,
                isDuplicatePresent = false;
            _.find(this.values, function(value, iter){
                // if value is a url, then compare with last
                var tempValue = value,
                    // can't use getOrElse here since value can have "." in URL and getOrElse splits based on period to find key inside object
                    fileName =  (_.isObject(self._initialFileValueFileNameMap) && typeof self._initialFileValueFileNameMap[value] !== undefined) ? self._initialFileValueFileNameMap[value] : null;
                if(tempValue.match(/\//g) && tempValue.match(/\//g).length > 1){
                    tempValue =  value.substring(value.lastIndexOf("/")+1);
                    tempValue = xfalib.ut.Utilities._getNameWithoutMarker(tempValue);
                }
                // we pass file name explicityly as options, if passed use that as fallback to find the URL
                if(tempValue === text || fileName === text){
                    index = iter;
                    isDuplicatePresent = self.values.indexOf(value, index + 1) !== -1;
                    if($elem && isDuplicatePresent){
                        // now check if duplicate present and get its correct index
                        // today all files are wrapped under .guide-fu-fileItem node
                        index = $elem.closest(".guide-fu-fileItem").index();
                    }
                    // check if there is a duplicate
                    // this is to just break the loop
                    return value;
                }
            });
            return index;
        },


        /*
         * Since input file element might contain multiple files.
         * This function takes absolute file index as parameter & returns position of the file w.r.t input file elt
         */
        _getFileObjIdx : function (index) {
            if (index >= 0) {
                var currentIdx = 0;
                for (var fileInputEltIdx = 0; fileInputEltIdx < this.$fileDomElements.length; fileInputEltIdx++) {
                    if (this.$fileDomElements[fileInputEltIdx]) {
                        var files = this.$fileDomElements[fileInputEltIdx][0].files;
                        if (files) {
                            var filesLength =  files.length;
                            if ( index <= currentIdx + filesLength - 1 ) {
                                return [fileInputEltIdx, index - currentIdx];
                            }
                            currentIdx+=files.length;
                        }
                    } else {
                        if (index == currentIdx) {
                            return [fileInputEltIdx,0];
                        }
                        currentIdx++;
                    }
                }
            }
            return null;
        },

        /*
         * This function returns FileList object of the passed file array
         */
        _getFileListItem : function (files) {
            try {
                var dataContainer = new DataTransfer() || (new ClipboardEvent("")).clipboardData;
                _.each(files, function (file) {
                    dataContainer.items.add(file);
                });
                return dataContainer.files;
            } catch(err) {
                console.error(err);
                throw err;
            }
        },

        _updateFilesInDom : function($fileDom, files) {
            // in safari, a change event is trigged if files property is changed dynamically
            // hence adding this check to clear existing state only for safari browsers
            this._isFileUpdate = true;
            $fileDom[0].files = this._getFileListItem(files);
            this._isFileUpdate = false;
        },

        /*
         * This function deletes files at specified indexes from input dom elt
         */
        _deleteFilesFromInputDom : function ($fileDomElt, deletedIndexes) {
            var remainingFiles = [];
            _.each($fileDomElt[0].files, function(file,idx){
                if(!deletedIndexes.includes(idx)){
                    remainingFiles.push(file);
                }
            });
            try {
                // in safari, a change event is trigged if files property is changed dynamically
                // hence adding this check to clear existing state only for safari browsers
                this._updateFilesInDom($fileDomElt, remainingFiles);
            } catch(err){
                console.error("Deleting files is not supported in your browser");
            }
        },

        /**
         * This event listener gets called on click of close button in file upload
         *
         * @param event
         */
        handleClick: function(event){

            var $elem = $(event.target),
                text = $elem.prev().text(),
                index = this._getIndexOfText(text, $elem),
                url = $elem.prev().data("key"),
                objectUrl = $elem.prev().data("objectUrl");
            if (index != -1) {
                this.values.splice(index, 1);
                var fileObjIdx = this._getFileObjIdx(index);
                var $fileDomElt = this.$fileDomElements[fileObjIdx[0]];
                if (!$fileDomElt || $fileDomElt[0].files.length === 1) {
                    this.$fileDomElements.splice(fileObjIdx[0], 1);
                } else {
                    this._deleteFilesFromInputDom($fileDomElt, [fileObjIdx[1]]);
                }
                if (isBrowserIE9OrIE10) {
                    this.cloneFileInputAndUpdateIdForIE9();
                }
                if (url != null) {
                    // remove the data so that others don't use this url
                    $elem.prev().removeData("key");
                }
                if(objectUrl) {
                    // revoke the object URL to avoid memory leaks in browser
                    // since file is anyways getting deleted, remove the object URL's too
                    window.URL.revokeObjectURL(objectUrl);
                }
            }
            // Remove the dom from view
            //All bound events and jQuery data associated with the element are also removed
            $elem.parent().remove();
            // trigger the change event to update the value
            this.$element.trigger("change.fileupload");
            // Set the focus on file upload button after click of close
            this.$elementFileUploadBtn.focus();

        },


        displaySVG(objectUrl) {
            const url = objectUrl;
            const img = window.document.createElement('img');
            img.src = url;
            const newTab = window.open('', '_blank', 'scrollbars=no,menubar=no,height=600,width=800,resizable=yes,toolbar=no,status=no');
            newTab.document.body.appendChild(img);
        },


        _previewFileUsingObjectUrl : function (file) {
            if (file) {
                if (window.navigator && window.navigator.msSaveOrOpenBlob) { // for IE
                    window.navigator.msSaveOrOpenBlob(file, file.name);
                } else {
                    var url = window.URL.createObjectURL(file);
                    if (file.type === 'image/svg+xml') {
                        this.displaySVG(url);
                    } else {
                        window.open(url, '', 'scrollbars=no,menubar=no,height=600,width=800,resizable=yes,toolbar=no,status=no');
                    }
                    return url;
                }
            }
        },

        // this function maintains a map for
        handleFilePreview: function(event){
            if(!this.options.disablePreview) {
                var $elem = $(event.target),
                    text = $elem.text(),
                    index = this._getIndexOfText(text, $elem),
                    fileDom = null,
                    fileName = null,
                    fileUrl = null,
                    timeStamp = new Date().getTime();

                // for draft usecase, if text contains "/" in it, it means the file is already uploaded
                // text should contain the path, assuming that the fileUrl is stored in data element

                if (index != -1) {
                    // Store the url of file as data
                    if(!_.isUndefined($elem.data("key")))
                        fileUrl = $elem.data("key");

                    if(fileUrl)  {
                        //prepend context path if not already appended
                        if (!(fileUrl.lastIndexOf(this.options._getUrl, 0) === 0)) {
                            fileUrl =  this.options._getUrl + fileUrl;
                        }
                        this.previewFile.apply(this, [null, {"fileUrl" : fileUrl}]);
                    } else {
                        var previewFileObjIdx = this._getFileObjIdx(index);
                        var previewFile = this.$fileDomElements[previewFileObjIdx[0]][0].files[previewFileObjIdx[1]];
                        var objectUrl = this._previewFileUsingObjectUrl(previewFile);
                        if (objectUrl) {
                            $elem.data("objectUrl", objectUrl);
                        }
                    }
                }
            }
        },

        previewFile: function(event){
            var url = null;
            if(_.isUndefined(arguments[1]))
                url = this.$element[this.options.uploaderPluginName]("getFileUrl");
            else
                url = arguments[1].fileUrl;
            var lastIndex = url.lastIndexOf('/');
            //to make sure url has a slash '/'
            if(lastIndex >= 0) {
                //encode the filename after last slash to ensure the handling of special characters
                url = url.substr(0, lastIndex) +'/'+ encodeURIComponent(url.substr(lastIndex + 1));
            }
            // this would work for dataURl or normal URL
            // todo: add support to preview base 64 encoded image, to preview base64 encoded binary, we would probably need
            // todo: the content type in the widget too
            window.open(url, '', 'scrollbars=no,menubar=no,height=600,width=800,resizable=yes,toolbar=no,status=no');

        },

        resetIfNotMultiSelect: function(){
            if(!this.options.multiSelect){
                // Reset the value and file array
                this.values = [];
                //this.comments = [];
            }
        },

        showFileList: function(fileName, comment, fileUrl){
            if(!this.options.multiSelect || fileName == null || _.isUndefined(fileName)) {
                // if not multiselect, remove all the children of file list
                this.$elementFileList.empty();
            }

            // Add the file item
            // On click of close, remove the element and update the model
            // handle on click of preview button
            if(fileName != null) {
                this.$fileItem = this.$elementFileList.append(this.fileItem(fileName, comment, fileUrl));
            }
        },

        /**
         * Handles the click on comment field
         *
         * TODO: Implement show/hide behaviour instead of replaceWith
         * This may be cause problem during bubble up of event
         *
         * @param event
         */
        handleCommentClick : function(event){
            var $commentElem = null,
                $elem = $(event.target);
            if ($elem.text() === _defaults.placeHolderText) {
                $commentElem = this.getNewCommentElement()
            } else {
                $commentElem = this.getNewCommentElement($(event.target).text());
            }
            $elem.replaceWith($commentElem);
            // register the event again
            if(isBrowserIE9OrIE10){
                $commentElem.focus().focusout($.proxy(this.handleCommentBlur, this));
            } else {
                $commentElem.focus().blur($.proxy(this.handleCommentBlur, this));
            }
        },

        handleCommentBlur : function(event){
            var $commentSummaryElem = null,
                $elem = $(event.target);
            if ($elem.text() === _defaults.placeHolderText) {
                $commentSummaryElem = this.getNewCommentElementSummary();
            } else {
                $commentSummaryElem = this.getNewCommentElementSummary($(event.target).text());
            }
            $elem.replaceWith($commentSummaryElem);
            $commentSummaryElem.focus($.proxy(this.handleCommentClick,this)).click($.proxy(this.handleCommentClick,this));
            // Add a div with the html
            this.$element.trigger("change.fileupload");
        },

        // checks if file name is valid or not to prevent security threats
        isValid : function(fname) {
            var rg1=/^[^\\/:\*\;\$\%\?"<>\|]+$/; // forbidden characters \ / : * ? " < > | ; % $
            var rg2=/^\./; // cannot start with dot (.)
            var rg3=/^(nul|prn|con|lpt[0-9]|com[0-9])(\.|$)/i; // forbidden file names
            return rg1.test(fname) && !rg2.test(fname) && !rg3.test(fname);
        },

        handleChange: function (evnt) {
            if (!this._isFileUpdate) {
                var currFileName = '',
                    inValidSizefileNames = '',
                    inValidNamefileNames = '',
                    inValidMimeTypefileNames = '',
                    $elem = $(evnt.target),
                    files = $elem[0].files;
                // Initially set the invalid flag to false
                // if not multiselect then remove the extra domELement clone
                if (!this.options.multiSelect && this.$fileDomElements.length > 1) {
                    this.$fileDomElements.splice(0, 1)
                }

                var isInvalidSize = false,
                    isInvalidFileName = false,
                    isInvalidMimeType = false;
                this.resetIfNotMultiSelect();
                // Iterate through all the files
                if (isBrowserIE9OrIE10) { // IE9 doesn't support FileList, hence files variable is undefined
                    currFileName = $elem.val().split("\\").pop();
                    //update the last element of array
                    if (this.$fileDomElements.length > 0) {
                        this.$fileDomElements[this.$fileDomElements.length - 1] = $elem;
                    }
                    this.cloneFileInputAndUpdateIdForIE9();

                    // In case of IE9, only do this
                    if (_.isUndefined(files)) {
                        this.showFileList(currFileName);
                        this.values.push(currFileName);
                        // trigger the change event to update the value
                        this.$element.trigger("change.fileupload");
                    }
                }
                if (!_.isUndefined(files)) {
                    var invalidFilesIndexes = [];
                    _.each(files, function (file, fileIndex) {
                        var isCurrentInvalidFileSize = false,
                            isCurrentInvalidFileName = false,
                            isCurrentInvalidMimeType = false;
                        currFileName = file.name.split("\\").pop();
                        // Now size is in MB
                        var size = file.size / 1024 / 1024;
                        // check if file size limit is within limits
                        if ((size > parseFloat(this.options.fileSizeLimit))) {
                            isInvalidSize = isCurrentInvalidFileSize = true;
                            inValidSizefileNames = currFileName + "," + inValidSizefileNames;
                        } else if (!this.isValid(currFileName)) {
                            // check if file names are valid (ie) there are no control characters in file names
                            isInvalidFileName = isCurrentInvalidFileName = true;
                            inValidNamefileNames = currFileName + "," + inValidNamefileNames;
                        } else if (file.type) {
                            var isMatch = this.regexMimeTypeList.some(function (rx) {
                                return rx.test(file.type);
                            });
                            if (!isMatch) {
                                isInvalidMimeType = isCurrentInvalidMimeType = true;
                                inValidMimeTypefileNames = currFileName + "," + inValidMimeTypefileNames;
                            }
                        }

                        // if the file is not invalid, show it and push it to internal array
                        if (!isCurrentInvalidFileSize && !isCurrentInvalidFileName && !isCurrentInvalidMimeType) {
                            this.showFileList(currFileName);
                            this.values.push(currFileName);
                        } else {
                            invalidFilesIndexes.push(fileIndex);
                        }


                    }, this);

                    if (invalidFilesIndexes.length > 0) {
                        var currentFileDomIndex,
                            $currentFileDomElement,
                            filesCount;
                        if (this.$fileDomElements.length > 0) {
                            currentFileDomIndex = this.$fileDomElements.length - 1;
                            $currentFileDomElement = this.$fileDomElements[currentFileDomIndex];
                            if ($currentFileDomElement && $currentFileDomElement.length > 0) {
                                filesCount = $currentFileDomElement[0].files.length;
                                //if all the files are invalid remove the input element as well otherwise only remove the invalid files.
                                if (filesCount === invalidFilesIndexes.length) {
                                    this.$fileDomElements.splice(-1, 1);
                                } else {
                                    this._deleteFilesFromInputDom($currentFileDomElement, invalidFilesIndexes);
                                }
                            }
                        }

                        // in case of IE10, create one extra element
                        if (isBrowserIE9OrIE10) {
                            this.cloneFileInputAndUpdateIdForIE9();
                        }
                    }

                    // trigger the change event to update the value
                    this.$element.trigger("change.fileupload");
                }

                if (isInvalidSize) {
                    this.showInvalidMessage(inValidSizefileNames.substring(0, inValidSizefileNames.lastIndexOf(',')), this.invalidFeature.SIZE);
                } else if (isInvalidFileName) {
                    this.showInvalidMessage(inValidNamefileNames.substring(0, inValidNamefileNames.lastIndexOf(',')), this.invalidFeature.NAME);
                } else if (isInvalidMimeType) {
                    this.showInvalidMessage(inValidMimeTypefileNames.substring(0, inValidMimeTypefileNames.lastIndexOf(',')), this.invalidFeature.MIMETYPE);
                }
            }
        },

        cloneFileInputAndUpdateIdForIE9 : function(){
            var elem = _.last(this.$fileDomElements),
                elemExists = elem != null,
                elemHasValue = elemExists && elem.val().length > 0,
                elemId = null,
                selector = null;

            // CQ-4237903 : create clone to handle the case when user clicks cancel in chrome and for multiselect
            // on clicking cancel in chrome file browser, chrome removes all the files from the input element
            // remove the extra clone in $fileDomElement on handleChange
            if(!elemExists || elemHasValue) {
                elem = this.$element.clone();
                // copy the data attributes
                elem.data(this.$element.data());
                if(isBrowserIE9OrIE10){
                    elemId = this.$element.attr("id") + (++fileLabelsCount);
                    elem.attr("id", elemId);
                    elem.css({
                        'position' : 'absolute',
                        'top' : '-2000px',
                        'left': '-2000px'
                    });
                    elem.appendTo('body');
                    this.updateLabelForAttr(elemId);
                }
                elem.change($.proxy(this.handleChange, this));
                this.$fileDomElements.push(elem);
            }
            // Case: if it is not multiselect and if the first file dom element is null
            // this case would hit when we restore a single select file attachment and attach a new file
            if(!this.options.multiSelect && this.$fileDomElements[0] === null){
                //Splice null out of it, since we are attaching a new file
                this.$fileDomElements.splice(0, 1);
            }
            // if the browser is not IE9, then click it
            if(!isBrowserIE9OrIE10) {
                elem.click();
            }
            return true;
        },

        /**
         * In case of IE9, get the last element of fileDom and update the id for label
         *
         * @param fileInputId
         */
        updateLabelForAttr : function(fileInputId){
            this.$label.attr("for" , fileInputId);
        },

        createLabelForFileInput : function (fileInputId){
            if(isBrowserIE9OrIE10) {
                this.$label = $("<label></label>").addClass("guide-fu-attach-button button")
                        .text(this.options.buttonText)
                        .attr('for',fileInputId);
                this.$elementFileUploadBtn.replaceWith(this.$label);
                this.$label.parent().attr("tabindex", 0).attr("role", "button").attr("aria-label", this.options.screenReaderText || "");
            }
        },


        constructor: function () {
            // Initialize the self instance
            var _self = this,
                isFirst = true;
            //jquery instance of file upload button
            this.$elementFileUploadBtn = this.$parent.find(this.options.buttonClass);
            this.$elementFileUploadBtn.attr("aria-label", this.options.screenReaderText || "");
            if(isBrowserIE9OrIE10){
                this.elementId = this.$element.attr("id");
                this.createLabelForFileInput(this.$element.attr("id"));
            }

            // html for file list
            this.$elementFileList = $(this.fileItemList());
            // Initialize the value and file(Refer FileList class mdn)
            this.values = [];
            this._initialFileValueFileNameMap = {};
            // List of dom elements of input type file
            this.$fileDomElements = [];

            var flag = false,
                $currElem = null;

            $(document).mousedown(function(e) {
                $currElem = $(e.target);
            });
            // Enter key should result in click of button
            this.$elementFileUploadBtn
                .focus(function(){
                    _self.$element.trigger("focus.fileupload");
                })
                .click($.proxy(this.cloneFileInputAndUpdateIdForIE9, this))
                .blur(function(event){
                    // Check if the currElem does not belong to the fileItemList
                    if(!flag && $currElem!= null && $currElem.closest(".guide-fu-fileItemList").length <=0){
                        _self.$element.trigger("focusout.fileupload");
                    }
                    flag = false;
                });
            //Initialize the filePreview Plugin
            this.$element[this.options.uploaderPluginName]({
                iframeContainer: this.options.iframeContainer,
                _filePath: this.options._filePath,
                _uuidGenerator: this.options._uuidGenerator,
                _getUrl: this.options._getUrl

            });
            // Getting input file value
            // listening on fileuploaded event
            this.$element.change($.proxy(this.handleChange, this))
                .on("adobeFileUploader.fileUploaded", $.proxy(this.previewFile, this));
        }
    };

    $.fn.adobeFileAttachment = function (option, value) {
        var get = '',
            element = this.each(function () {
                // in case of input type file
                if ($(this).attr('type') === 'file') {
                    var $this = $(this),
                        data = $this.data('adobeFileAttachment'),
                        options = $.extend({}, AdobeFileAttachment.prototype.defaults, typeof option === 'object' && option);

                    // Save the adobeFileAttachment data in jquery
                    if (!data) {
                        $this.data('adobeFileAttachment', (data = new AdobeFileAttachment(this, options)));
                        data.constructor();
                    }

                    // code to get and set an option
                    if (typeof option === 'string') {
                        get = data[option](value);
                    }
                }
            });

        if (typeof get !== 'undefined') {
            return get;
        } else {
            return element;
        }
    };

    // fileSizeLimit is in MB, default value is 2MB
    AdobeFileAttachment.prototype.defaults = {
        'buttonText': 'Attach',
        'multiSelect': false,
        'fileSizeLimit': 2,
        'uploaderPluginName': "adobeFileUploader",
        'mimeType' : ['audio/*', 'video/*', 'image/*', 'text/*', 'application/pdf']
    };

})($, window, window._);
(function($, _) {
    var xfaUtil = xfalib.ut.XfaUtil.prototype;
    $.widget( "xfaWidget.fileUpload", $.xfaWidget.abstractWidget, {

        _widgetName:"fileUpload",
        _superPrototype : $.xfaWidget.abstractWidget.prototype,
        getOptionsMap: function(){
            var parentOptionsMap = this._superPrototype.getOptionsMap.apply(this,arguments),
                newMap = $.extend({},parentOptionsMap, $.extend({}, this.options, {
                    "value" : function(value) {
                        this.$userControl.adobeFileAttachment("value", value);
                    },
                    "fileList": function(value){
                        this.$userControl.adobeFileAttachment("fileList", value);
                    },
                    "comment" : function(value){
                        this.$userControl.adobeFileAttachment("comment", value);
                    },
                    // "access" can be either open or readonly
                    "access" : function(value){
                        this.$userControl.adobeFileAttachment("access", value);
                    }

                }));

            return newMap;

        },
        // TODO: Will need to remove this functions
        //  will be tracked by LC-391200

        _initializeOptions: function () {
            _.each(this.optionsHandler, function (value, key) {
                // overriding the behaviour of _initializeOptions
                // only for _uuidGenerator
                // as we font want getUUID to be called at render time
                if (typeof value === "function" && key !== '_uuidGenerator' ) {
                        value.apply(this, [this.options[key]])
                }
            }, this)
        },

        _getFileList: function(){
            return this.$userControl.adobeFileAttachment("fileList");
        },

        _getComment: function(){
            return this.$userControl.adobeFileAttachment("comment");
        },
        _getFileNamePathMap: function (pathList) {
            return this.$userControl.adobeFileAttachment("getSetFilePathAndReturnNamePathMap", pathList);
        },
        getEventMap: function() {
            var parentEventMap = this._superPrototype.getEventMap.apply(this, arguments),
                newMap = $.extend({}, parentEventMap,
                    {
                        "change" : null,
                        "focusout.fileupload" : xfaUtil.XFA_EXIT_EVENT,
                        "focus.fileupload" : xfaUtil.XFA_ENTER_EVENT,
                        "change.fileupload" : xfaUtil.XFA_CHANGE_EVENT
                    });
            return newMap;
        },
        render: function() {
            var $el = this._superPrototype.render.apply(this,arguments);
            $el.adobeFileAttachment(this.getOptionsMap());
            return $el;
        },
        showDisplayValue: function() {
             //since value can't be set in file element input, leaving this fn empty
        },
        showValue: function() {
            //since value can't be set in file element input, leaving this fn empty
        },
        getCommitValue: function() {
            this.options.fileList = this._getFileList();
            this.options.comment = this._getComment();
            return this.$userControl.adobeFileAttachment("value");
        }
    });
})($, window._);

/**
 * Adobe FilePreview Widget Plugin
 *
 * Options expected by file preview is the url
 *
 * Options Required Are:
 *
 *  iframeName: Name of the Iframe
 *  iframeContainer: Container of the iframe(eg Body)
 *  fileUploadPath: Path where the file is to be uploaded
 *  fileUploadServlet: Servlet where the file is to be uploaded
 *
 */
(function ($, _) {

    var AdobeFileUploader = function (element, options) {
        this.options = options;
        this.$element = $(element);
    };

    AdobeFileUploader.prototype = {

        _fileIframeName: "guide-fu-iframe",

        _filePath: "/tmp/fd/mf",

        _iframeContainer: "body#formBody",


        fileIframe: function (name) {
            return $("<iframe></iframe>").attr({
                style: "display:none",
                name: name
            });
        },

        uploadFile: function (fileObject) {
            var multiple = false,
                fileName = null,
                actionUrl = null,
                fileUploadPath = fileObject.fileUploadPath,
                uuid;

            if (!fileUploadPath) {
                uuid = fileObject._uuidGenerator();
            }

            // if uuid exists only then upload the file in the current  instance
            if (_.isObject(fileObject) && (fileUploadPath || uuid)) {
                var fileDom = fileObject.fileDom,
                    $form = $(this.options.iframeContainer).find(".filePreview");
                fileName = fileObject.fileName;
                multiple = fileObject.multiple;
                if(!fileUploadPath) {
                    fileUploadPath = this.options.fileUploadPath + "/" + uuid;
                }
                if (fileDom !== null) {
                    //prepend contextpath
                    actionUrl = fileObject._getUrl + fileUploadPath;
                    if (!multiple) {
                        if (!(fileUploadPath.lastIndexOf(fileObject._getUrl, 0) === 0)) {
                            this.fileUrl = fileObject._getUrl + fileUploadPath + "/" + fileName;
                        } else {
                            this.fileUrl = fileUploadPath + "/" + fileName;
                        }
                    } else {
                        this.fileUrl = actionUrl;
                    }
                    // done to solve issue LC-5835
                    if($form.length === 0) {
                        $form = $("<form method='post' enctype='multipart/form-data'/>")
                            .addClass("filePreview")
                            // create id so that it does not intercept with other forms in the page
                            .attr({
                                id : "form" + new Date().valueOf(),
                                action : actionUrl,
                                target : this.options.iframeName
                            })
                            .appendTo(this.options.iframeContainer);
                    } else {
                        /// first empty all children, using detach so that data is not clear
                        $form.children().detach();
                        // now update the new attributes
                        $form.attr({
                            action : actionUrl,
                            target : this.options.iframeName
                        });
                    }
                    // this is done so that the other events attached at some other level in DOM Tree don't interfere
                    $form.one("submit", function(evnt){
                        evnt.stopPropagation();
                    });

                     var data = new FormData();

                    if (multiple) {
                        _.each(fileDom, function (fileDomElement, index) {
                            // OOTB, this code is still used in dashboard
                            if(fileDomElement !== null && !_.isString(fileDomElement)) {
                                $(fileDomElement[0]).attr('name', fileName[index]).appendTo($form);
                                // fileDomElement might contain multiple files so all the files needs to be added to formdata.
                                var currentFileNames = fileName[index].split("\n");
                                for(var fileIndex = 0; fileIndex < currentFileNames.length; fileIndex++) {
                                    data.append(currentFileNames[fileIndex], fileDomElement[0].files[fileIndex]);
                                }
                            }
                        }, this);
                    } else {
                        fileDom.attr('name', fileName).appendTo($form);
                        data.append(fileName, fileDom[0].files[0]);
                    }

                    /* UseCase: Suppose the fileName is in other language, on click of fileName, it tries to upload the file
                     so that it could be preview, this change would ensure that the file is properly previewed supporting
                     the given UTF-8 charset */
                    $("<input type='hidden' name='_charset_' value='UTF-8'/>").appendTo($form);
                    data.append("_charset_", "UTF-8");
                    if (!multiple) {
                        this.fileMap[this.fileUrl] = this.$element;
                    }
                    var self = this;
                    $.ajax({
                        url: $form.attr("action"),
                        data: data,
                        cache: false,
                        contentType: false,
                        processData: false,
                        method: 'POST',
                        type: 'POST',
                        success: function(data){
                            if (!multiple) {
                                self.handleSingleFileUpload(data);
                            } else {
                                self.handleMultipleFileUpload(data);
                            }
                        },
                        error: function() {
                            this.$element.trigger("adobeFileUploader.fileUploadFailed");
                        }
                    });
                }
            }
            return this.fileUrl;
        },

        handleMultipleFileUpload: function (data) {
            this.$element.trigger("adobeFileUploader.multipleFileUploaded");
        },

        getFileUrl: function () {
            return this.fileUrl;
        },

        getUrlContentsFromUploadData: function (data) {
            var temp;
            if(data != null) {
                temp = $(data).find("#ChangeLog").text().split("br", 2)[1];
            } else {
                var selector = this.options.iframeContainer + " iframe[name='" + this.options.iframeName + "']";
                temp = $(selector).contents().find("#ChangeLog").text().split("br", 2)[1];
            }
            
            temp = temp.substring(temp.indexOf("created") + 9, temp.indexOf(";<"));
            temp = temp.substring(0, temp.length - 2);
            var index = temp.indexOf("/jcr:content");
            if (index !== -1)
                temp = temp.substring(0, index);
            return temp;
        },

        handleSingleFileUpload: function (data) {
            var url = this.getUrlContentsFromUploadData(data);

            //prepend context path
            url = this.options._getUrl + url;
            if (url in this.fileMap) {
                this.fileMap[url].trigger("adobeFileUploader.fileUploaded");
            }
        },

        initialize: function () {
            // Put iframe inside the iframe container
            // On the load of iframe, display the contents of file
            // since there is only one iframe for all the file attachments, there may be race condition
            if (this.$iframe == null || this.$iframe.length === 0) {
                this.$iframe = this.fileIframe(this.options.iframeName).appendTo(this.options.iframeContainer);
                // since there is only iframe for the preview of all file attachments
                // this map is added in the closure scope
                // map contains the url(key) vs fileDomElement(value)
                // it helps avoids the race condition
                this.fileMap = {};
            }
        }
    };

    $.fn.adobeFileUploader = function (option, value) {
        var get = '',
            element = this.each(function () {
                // in case of input type file
                if ($(this).attr('type') === 'file') {
                    var $this = $(this),
                        data = $this.data('adobeFileUploader'),
                        options = $.extend({}, AdobeFileUploader.prototype.defaults(option, value), typeof option === 'object' && option);

                    // Save the adobeFileAttachment data in jquery
                    if (!data) {
                        $this.data('adobeFileUploader', (data = new AdobeFileUploader(this, options)));
                        data.initialize();
                    } else {
                        // update elements if not equal, since sometimes one can clone too
                        if(data.$element.get(0) !== this) {
                            data.$element = $(this);
                        }
                    }

                    // code to get and set an option
                    if (typeof option === 'string') {
                        get = data[option](value);
                    }
                }
            });

        if (typeof get !== 'undefined') {
            return get;
        } else {
            return element;
        }
    };


    AdobeFileUploader.prototype.defaults = function (options,value)  {
        var propertyObject = {};
        if(typeof options == 'object') {
            propertyObject._fileIframeName = options._fileIframeName;
            propertyObject._filePath = options._filePath;
            propertyObject.actionUrl = options.actionUrl;
            propertyObject._getUrl = options._getUrl;
        }
        if(typeof  value == 'object') {
            propertyObject._fileIframeName = value._fileIframeName;
            propertyObject._filePath = value._filePath;
            propertyObject.actionUrl = value.actionUrl;
            propertyObject._getUrl = options._getUrl;
        }
        return {
            'fileUploadPath': propertyObject._filePath || AdobeFileUploader.prototype._filePath,
            'iframeName': AdobeFileUploader.prototype._fileIframeName + new Date().valueOf(),
            'fileUploadServlet': propertyObject._filePath || AdobeFileUploader.prototype._filePath,
            'iframeContainer': propertyObject._iframeContainer || AdobeFileUploader.prototype._iframeContainer,
            '_getUrl': propertyObject._getUrl || ""
        };
    };

})($, window._);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function(_,xfalib) {
    var Constants = {
        accessValues : ["open","protected","readOnly","nonInteractive"],
        presenceValues : ["visible", "hidden","inactive","invisible"],
        itemSaveValues : [0,1],
        valueOverrideValues : [0,1],
        oneOfChild : {type: "oneOfChild", min:0, max:1},
        zeroOrMore : {type: "zeroOrMore",min:0, max:Infinity},
        zeroOrOne : {type: "zeroOrOne",min:0, max:1},
        zeroOrTwo : {type: "zeroOrTwo", min:0, max:2},
        zeroOrFour : {type: "zeroOrFour", min:0, max:4},
        oneOrMore : {type: "oneOrMore", min:1, max:Infinity},

        encryptDataOperationValues : ["encrypt", "decrypt"],
        requiredTypeValues : ["optional", "required"],
        dataValues : ["link", "embed"],
        hScrollPolicyValues : ["auto", "off", "on"],
        disableAllValues : ["0", "1"],
        formatTestValues : ["warning", "disabled", "error"],
        nullTestValues : ["disabled", "error", "warning" ],
        scriptTestValues : ["error", "disabled", "warning"],
        afterValues : ["auto", "contentArea", "pageArea", "pageEven", "pageOdd"],
        beforeValues : ["auto", "contentArea", "pageArea", "pageEven", "pageOdd"],
        startNewValues : ["0", "1"],
        circularValues : ["0", "1"],
        handValues : ["even", "left", "right"],
        highlightValues : ["inverted", "none", "outline", "push"],
        activityValues : ["click", "change", "docClose", "docReady", "enter",
            "exit", "full", "indexChange", "initialize",
            "mouseDown", "mouseEnter", "mouseExit", "mouseUp",
            "postExecute", "postOpen", "postPrint", "postSave",
            "postSign", "postSubmit", "preExecute", "preOpen",
            "prePrint", "preSave", "preSign", "preSubmit",
            "ready", "validationState"],
        listenValues : ["refOnly", "refAndDescendents"],
        breakValues : ["close", "open"],
        targetTypeValues : ["auto", "contentArea", "pageArea", "pageEven", "pageOdd"],
        signTypeValues : ["PDF1.3", "PDF1.6"],
        signDataOperationValues : ["sign", "clear", "verify"],
        aspectValues : ["fit", "actual", "height", "none", "width"],
        transferEncodingValues : ["none", "package", "base64"],
        manifestActionValues : ["include", "all", "exclude"],
        traverseDelegateValues : ["0", "1"],
        traverseOperationValues : ["next", "back", "down", "first", "left", "right", "up"],
        slopeValues : ["\\", "/"],
        excludeAllCapsValues : ["0", "1"],
        excludeInitialCapValues : ["0", "1"],
        hyphenateValues : ["0", "1"],
        allowNeutralValues : ["0", "1"],
        markValues : ["default", "check", "circle", "cross", "diamond", "square", "star"],
        shapeValues : ["square", "round"],
        commitOnValues : [ "select", "exit"],
        openValues : ["userControl", "always", "multiSelect", "onEntry" ],
        textEntryValues : ["0", "1"],
        linearTypeValues : ["toRight", "toBottom", "toLeft", "toTop"],
        edgeCapValues : ["square", "butt", "round"],
        strokeValues : ["solid", "dashDot", "dashDotDot", "dashed", "dotted", "embossed", "etched", "lowered", "raised"],
        cornerInvertedValues : ["0", "1"],
        cornerJoinValues : ["square","round"],
        speakDisableValues : ["0", "1"],
        speakPriorityValues : [ "custom", "caption", "name", "toolTip"],
        captionPlacementValues : ["left", "bottom", "inline", "right", "top"],
        orientationValues : ["portrait", "landscape"],
        mediumTrayInValues : ["auto", "delegate", "pageFront"],
        mediumTrayOutValues : ["auto", "delegate"],
        patternTypeValues : ["crossHatch", "crossDiagonal", "diagonalLeft", "diagonalRight", "horizontal", "vertical"],
        keepIntactValues : ["none", "contentArea", "pageArea"],
        keepNextValues : ["none", "contentArea", "pageArea"],
        keepPreviousValues : ["none", "contentArea", "pageArea"],
        passThroughValues : ["0", "1"],
        allowRichTextValues : ["0", "1"],
        multiLineValues : ["1", "0"],
        vScrollPolicyValues : ["auto", "off", "on"],
        kerningModeValues : ["none", "pair"],
        lineThroughValues : ["0", "1", "2"],
        lineThroughPeriodValues : ["all", "word"],
        fontOverlineValues : ["0", "1", "2"],
        fontOverlinePeriodValues : ["all", "word"],
        postureValues : ["normal", "italic"],
        underlineValues : ["0", "1", "2"],
        underlinePeriodValues : ["all", "word"],
        fontWeightValues : ["normal", "bold"],
        checksumValues : ["none", "1mod10", "1mod10_1mod11", "2mod10", "auto"],
        dataPrepValues : ["none", "flateCompress"],
        printCheckDigitValues : ["0", "1"],
        textLocationValues : ["below", "belowEmbedded", "none", "above", "aboveEmbedded"],
        truncateValues : ["0", "1"],
        upsModeValues : ["usCarrier", "internationalCarrier", "secureSymbol", "standardSymbol"],
        mdpPermissionsValues : ["2", "1", "3"],
        mdpSignatureTypeValues : ["filler", "author"],
        connectUsageValues : ["exportAndImport", "exportOnly", "importOnly"],
        radialTypeValues : ["toEdge", "toCenter"],
        credentialServerPolicyValues : ["optional", "required"],
        dateTimeEditPickerValues : ["host", "none"],
        bindMatchValues : ["once", "dataRef", "global", "none"],
        runAtValues : ["client", "both", "server"],
        statelessValues : ["0", "1"],
        executeTypeValues : ["import", "remerge"],
        calcOverrideValues : ["disabled", "error", "ignore", "warning" ],
        embedPDFValues : ["0", "1"],
        submitFormatValues : ["xdp", "formdata", "pdf", "urlencoded", "xfd", "xml" ],
        setRelationValues : ["ordered" , "choice" , "unordered"],
        firstTraversal : "first",
        nextTraversal : "next",
        ScribbleImageField : "ScribbleImageField",
        scribbleChangeEvent : "scribbleChange",
        calendarIconMaxWidth : 40

    };
    xfalib.template.Constants = Constants;
})(_,xfalib);
(function(_, xfalib){

var XfaTemplateSchema = {};

var TemplateSchema = xfalib.template.TemplateSchema = xfalib.ut.Class.extend({
    initialize : function() {
        var elem = null;
        XfaTemplateSchema["field"] = elem = this.createElement();
        this.addAttributes(elem,[
                                    ["access",xfalib.template.Constants.accessValues,0],
                                    ["h","measurement",0],
                                    ["w","measurement",0],
                                    ["x","measurement",0],
                                    ["y","measurement",0],
                                    ["presence",xfalib.template.Constants.presenceValues,0],
                                    ["name","string",""],
                                    ["relevant", "string", "" ],
                                    ["locale","string","en_US"]
                                   ]);
        this.addChildren(elem, [
                                    ["items","zeroOrTwo"],
                                    ["extras","zeroOrOne"],
                                    ["desc","zeroOrOne"],
                                    ["event","zeroOrMore"],
                                    ["value","zeroOrOne"],
                                    ["ui","zeroOrOne"],
                                    ["assist","zeroOrOne"],
                                    ["border", "zeroOrOne"]  ,
                                    ["para", "zeroOrOne"]  ,
                                    ["caption", "zeroOrOne"]  ,
                                    ["validate","zeroOrOne"]  ,
                                    ["margin", "zeroOrOne"] ,
                                    ["font", "zeroOrOne"],
                                    ["calculate","zeroOrOne"],
                                    ["format","zeroOrOne"],
                                    ["bindItems","zeroOrMore"]
                                ]);

        XfaTemplateSchema["area"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["x","measurement",0],
            ["y","measurement",0],
            ["relevant", "string", "" ],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["field","zeroOrMore"],
            ["draw","zeroOrMore"],
            ["exclGroup","zeroOrMore"],
            ["instanceManager","zeroOrMore"],
            ["area","zeroOrMore"],
            ["subform","zeroOrMore"],
            ["subformSet","zeroOrMore"]
        ]);

        XfaTemplateSchema["subformSet"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["relation",xfalib.template.Constants.setRelationValues,0],
            ["relevant","string",""],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["bookend","zeroOrOne"],
            ["break","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["extras","zeroOrOne"],
            ["occur","zeroOrOne"],
            ["overflow","zeroOrOne"],
            ["breakAfter","zeroOrMore"],
            ["breakBefore","zeroOrMore"],
            ["instanceManager","zeroOrMore"],
            ["subform","zeroOrMore"],
            ["subformSet","zeroOrMore"]
        ]);

        XfaTemplateSchema["contentArea"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""],
            ["h","measurement",0],
            ["w","measurement",0],
            ["x","measurement",0],
            ["relevant", "string", "" ],
            ["y","measurement",0]
        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"]
        ]);

        XfaTemplateSchema["date"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);

        XfaTemplateSchema["decimal"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""],
            ["leadDigits","integer",-1],
            ["fracDigits","integer",2]
        ]);

        XfaTemplateSchema["draw"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["h","measurement",0],
            ["w","measurement",0],
            ["x","measurement",0],
            ["y","measurement",0],
            ["presence",xfalib.template.Constants.presenceValues,0],
            ["name","string",""],
            ["access", xfalib.template.Constants.accessValues, 0],  // TODO : fix schema violation
            ["relevant", "string", "" ],
            ["locale","string","en_US"]

        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["value","zeroOrOne"],
            ["ui","zeroOrOne"],
            ["border", "zeroOrOne"]  ,
            ["font", "zeroOrOne"]  ,
            ["para", "zeroOrOne"]  ,
            ["caption", "zeroOrOne"]  ,
            ["assist","zeroOrOne"],
            ["font", "zeroOrOne"],
            ["margin", "zeroOrOne"]
        ]);

        XfaTemplateSchema["exclGroup"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["access",xfalib.template.Constants.accessValues,0],
            ["h","measurement",0],
            ["w","measurement",0],
            ["x","measurement",0],
            ["y","measurement",0],
            ["relevant", "string", "" ],
            ["presence",xfalib.template.Constants.presenceValues,0],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["field","zeroOrMore"],
            ["assist","zeroOrOne"],
            ["border", "zeroOrOne"]  ,
            ["para", "zeroOrOne"]  ,
            ["caption", "zeroOrOne"]  ,
            ["validate","zeroOrOne"],
            ["margin", "zeroOrOne"]
        ]);

        XfaTemplateSchema["float"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);

        XfaTemplateSchema["integer"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);

        XfaTemplateSchema["items"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["save",xfalib.template.Constants.itemSaveValues,0],
            ["presence",xfalib.template.Constants.presenceValues,0],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["text","zeroOrMore"],
            ["integer","zeroOrMore"],
            ["date","zeroOrMore"],
            ["decimal","zeroOrMore"],
            ["float","zeroOrMore"]
        ]);

        XfaTemplateSchema["occur"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["initial","integer",1],
            ["max","integer",1],
            ["min","integer",1]
        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"]
        ]);

        XfaTemplateSchema["pageArea"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["relevant", "string", "" ],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["occur","zeroOrOne"],
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["area","zeroOrMore"],
            ["field","zeroOrMore"],
            ["draw","zeroOrMore"],
            ["exclGroup","zeroOrMore"],
            ["instanceManager","zeroOrMore"],
            ["subform","zeroOrMore"],
            ["contentArea","zeroOrMore"]
        ]);



        XfaTemplateSchema["pageSet"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["relevant", "string", "" ],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["occur","zeroOrOne"],
            ["extras","zeroOrOne"],
            ["pageArea","zeroOrMore"],
            ["pageSet","zeroOrMore"]
        ]);

        XfaTemplateSchema["subform"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["access",xfalib.template.Constants.accessValues,0],
            ["h","measurement",0],
            ["w","measurement",0],
            ["x","measurement",0],
            ["y","measurement",0],
            ["presence",xfalib.template.Constants.presenceValues,0],
            ["name","string",""],
            ["relevant", "string", "" ],
            ["locale","string","en_US"]
        ]);
        this.addChildren(elem, [
            ["occur","zeroOrOne"],
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["pageSet","zeroOrOne"],
            ["variables","zeroOrOne"],
            ["area","zeroOrMore"],
            ["field","zeroOrMore"],
            ["draw","zeroOrMore"],
            ["exclGroup","zeroOrMore"],
            ["instanceManager","zeroOrMore"],
            ["subform","zeroOrMore"],
            ["assist","zeroOrOne"],
            ["border", "zeroOrOne"],
            ["para", "zeroOrOne"],
            ["validate","zeroOrOne"],
            ["subformSet","zeroOrMore"],
            ["bind","zeroOrOne"],
            ["margin", "zeroOrOne"]
        ]);

        XfaTemplateSchema["text"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""],
            ["maxChars","integer",0]
        ]);

        XfaTemplateSchema["exData"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""],
            ["maxLength","integer",-1],
            ["transferEncoding",xfalib.template.Constants.transferEncodingValues,0],
            ["contentType","string","text/plain"]
        ]);


        XfaTemplateSchema["extras"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["text","zeroOrMore"],
            ["integer","zeroOrMore"],
            ["date","zeroOrMore"],
            ["decimal","zeroOrMore"],
            ["float","zeroOrMore"],
            ["value", "zeroOrOne"],
            ["extras","zeroOrMore"]
        ]);

        XfaTemplateSchema["desc"] = elem = this.createElement();
        this.addChildren(elem, [
            ["text","zeroOrMore"],
            ["integer","zeroOrMore"],
            ["date","zeroOrMore"],
            ["decimal","zeroOrMore"],
            ["float","zeroOrMore"]
        ]);

        XfaTemplateSchema["variables"] = elem = this.createElement();
        this.addChildren(elem, [
            ["boolean","zeroOrMore"],
            ["date","zeroOrMore"],
            ["dateTime","zeroOrMore"],
            ["decimal","zeroOrMore"],
            ["exData","zeroOrMore"],
            ["float","zeroOrMore"],
            ["image","zeroOrMore"],
            ["integer","zeroOrMore"],
            ["manifest","zeroOrMore"],
            ["script","zeroOrMore"],
            ["script","zeroOrMore"],
            ["time","zeroOrMore"]
        ]);


//------------------------------------------------------------------------------------------------------------------------------
        XfaTemplateSchema["para"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hAlign","string","left"],
            ["lineHeight","measurement","0pt"],
            ["marginLeft","measurement","0in"],
            ["marginRight","measurement","0in"],
            ["orphans","integer",0],
            ["preserve","string",""],
            ["radixOffset","measurement","0in"],
            ["spaceAbove","measurement","0in"],
            ["spaceBelow","measurement","0in"],
            ["tabDefault","string",""],
            ["tabStops","string",""],
            ["textIndent","measurement","0in"],
            ["vAlign","string","top"],
            ["widows","integer",0],
            ["wordSpacingMaximum","string",""],
            ["wordSpacingMinimum","string",""],
            ["wordSpacingOptimum","string",""]
        ]);

        XfaTemplateSchema["encryptData"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["operation", xfalib.template.Constants.encryptDataOperationValues, 0 ]  ,
            ["target", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["filter", "zeroOrOne"]  ,
            ["manifest", "zeroOrOne"]
        ]);


        XfaTemplateSchema["issuers"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["certificate", "zeroOrMore"]
        ]);


        XfaTemplateSchema["imageEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["data", xfalib.template.Constants.dataValues, 1 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["bookend"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["leader", "string", "" ]  ,
            ["trailer", "string", "" ]
        ]);


        XfaTemplateSchema["reason"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);


        XfaTemplateSchema["passwordEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hScrollPolicy", xfalib.template.Constants.hScrollPolicyValues, 0 ]  ,
            ["passwordChar", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["validate"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["disableAll", xfalib.template.Constants.disableAllValues, 0 ]  ,
            ["formatTest", xfalib.template.Constants.formatTestValues, 0 ]  ,
            ["nullTest", xfalib.template.Constants.nullTestValues, 0 ]  ,
            ["scriptTest", xfalib.template.Constants.scriptTestValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["message", "zeroOrOne"]  ,
            ["picture", "zeroOrOne"]  ,
            ["script", "zeroOrOne"]
        ]);


        XfaTemplateSchema["break"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["after", xfalib.template.Constants.afterValues, 0 ]  ,
            ["afterTarget", "string", "" ]  ,
            ["before", xfalib.template.Constants.beforeValues, 0 ]  ,
            ["beforeTarget", "string", "" ]  ,
            ["bookendLeader", "string", "" ]  ,
            ["bookendTrailer", "string", "" ]  ,
            ["overflowLeader", "string", "" ]  ,
            ["overflowTarget", "string", "" ]  ,
            ["overflowTrailer", "string", "" ]  ,
            ["startNew", xfalib.template.Constants.startNewValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["time"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["certificate"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["lockDocument"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);


        XfaTemplateSchema["arc"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["circular", xfalib.template.Constants.circularValues, 0 ]  ,
            ["hand", xfalib.template.Constants.handValues, 0 ]  ,
            ["startAngle", "string", "0" ]  ,
            ["sweepAngle", "string", "360" ]
        ]);
        this.addChildren(elem, [
            ["edge", "zeroOrOne"]  ,
            ["fill", "zeroOrOne"]
        ]);


        XfaTemplateSchema["button"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["highlight", xfalib.template.Constants.highlightValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["event"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["activity", xfalib.template.Constants.activityValues, 0 ]  ,
            ["listen", xfalib.template.Constants.listenValues, 0 ]  ,
            ["name", "string", "" ],
            ["ref", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["encryptData", "oneOfChild"]  ,
            ["execute", "oneOfChild"]  ,
            ["script", "oneOfChild"]  ,
            ["signData", "oneOfChild"]  ,
            ["submit", "oneOfChild"]
        ]);


        XfaTemplateSchema["boolean"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["margin"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["bottomInset", "measurement", "0in" ]  ,
            ["leftInset", "measurement", "0in" ]  ,
            ["rightInset", "measurement", "0in" ]  ,
            ["topInset", "measurement", "0in" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["border"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["break", xfalib.template.Constants.breakValues, 0 ]  ,
            ["hand", xfalib.template.Constants.handValues, 0 ]  ,
            ["presence", xfalib.template.Constants.presenceValues, 0 ]  ,
            ["relevant", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["corner", "zeroOrFour"]  ,
            ["edge", "zeroOrFour"]  ,
            ["extras", "zeroOrOne"]  ,
            ["fill", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["breakAfter"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["leader", "string", "" ]  ,
            ["startNew", xfalib.template.Constants.startNewValues, 0 ]  ,
            ["target", "string", "" ]  ,
            ["targetType", xfalib.template.Constants.targetTypeValues, 0 ]  ,
            ["trailer", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["script", "zeroOrOne"]
        ]);


        XfaTemplateSchema["signature"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.signTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["filter", "zeroOrOne"]  ,
            ["manifest", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["signData"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["operation", xfalib.template.Constants.signDataOperationValues, 0 ]  ,
            ["ref", "string", "" ]  ,
            ["target", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["filter", "zeroOrOne"]  ,
            ["manifest", "zeroOrOne"]
        ]);


        XfaTemplateSchema["image"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["aspect", xfalib.template.Constants.aspectValues, 0 ]  ,
            ["contentType", "string", "" ]  ,
            ["href", "string", "" ]  ,
            ["name", "string", "" ]  ,
            ["transferEncoding", xfalib.template.Constants.transferEncodingValues, 2 ]
        ]);


        XfaTemplateSchema["oids"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["oid", "zeroOrMore"]
        ]);


        XfaTemplateSchema["solid"] = elem = this.createElement();
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["manifest"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["action", xfalib.template.Constants.manifestActionValues, 0 ],
            ["name", "string", "2" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["ref", "zeroOrMore"]
        ]);



        XfaTemplateSchema["traverse"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["delegate", xfalib.template.Constants.traverseDelegateValues, 0 ]  ,
            ["operation", xfalib.template.Constants.traverseOperationValues, 0 ]  ,
            ["ref", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["script", "zeroOrOne"]
        ]);


        XfaTemplateSchema["line"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hand", xfalib.template.Constants.handValues, 0 ]  ,
            ["slope", xfalib.template.Constants.slopeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["edge", "zeroOrOne"]
        ]);


        XfaTemplateSchema["digestMethods"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["digestMethod", "zeroOrMore"]
        ]);


        XfaTemplateSchema["reasons"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["reason", "zeroOrMore"]
        ]);


        XfaTemplateSchema["defaultUi"] = elem = this.createElement();
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["hyphenation"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["excludeAllCaps", xfalib.template.Constants.excludeAllCapsValues, 0 ]  ,
            ["excludeInitialCap", xfalib.template.Constants.excludeInitialCapValues, 0 ]  ,
            ["hyphenate", xfalib.template.Constants.hyphenateValues, 0 ]  ,
            ["ladderCount", "integer", 2 ]  ,
            ["pushCharacterCount", "integer", 3 ]  ,
            ["remainCharacterCount", "integer", 3 ]  ,
            ["wordCharacterCount", "integer", 7 ]
        ]);


        XfaTemplateSchema["rectangle"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hand", xfalib.template.Constants.handValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["corner", "zeroOrFour"]  ,
            ["edge", "zeroOrFour"]  ,
            ["fill", "zeroOrOne"]
        ]);


        XfaTemplateSchema["encryptionMethod"] = elem = this.createElement();


        XfaTemplateSchema["checkButton"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["allowNeutral", xfalib.template.Constants.allowNeutralValues, 0 ]  ,
            ["mark", xfalib.template.Constants.markValues, 0 ]  ,
            ["shape", xfalib.template.Constants.shapeValues, 0 ]  ,
            ["size", "string", "10pt" ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["choiceList"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["commitOn", xfalib.template.Constants.commitOnValues, 0 ]  ,
            ["open", xfalib.template.Constants.openValues, 0 ]  ,
            ["textEntry", xfalib.template.Constants.textEntryValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["oid"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["encoding"] = elem = this.createElement();


        XfaTemplateSchema["ui"] = elem = this.createElement();
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["picture", "zeroOrOne"]  ,
            ["barcode", "oneOfChild"]  ,
            ["button", "oneOfChild"]  ,
            ["checkButton", "oneOfChild"]  ,
            ["choiceList", "oneOfChild"]  ,
            ["dateTimeEdit", "oneOfChild"]  ,
            ["defaultUi", "oneOfChild"]  ,
            ["exObject", "oneOfChild"]  ,
            ["imageEdit", "oneOfChild"]  ,
            ["numericEdit", "oneOfChild"]  ,
            ["passwordEdit", "oneOfChild"]  ,
            ["signature", "oneOfChild"]  ,
            ["textEdit", "oneOfChild"]
        ]);


        XfaTemplateSchema["linear"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.linearTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["edge"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["cap", xfalib.template.Constants.edgeCapValues, 0 ]  ,
            ["presence", xfalib.template.Constants.presenceValues, 0 ]  ,
            ["stroke", xfalib.template.Constants.strokeValues, 0 ]  ,
            ["thickness", "string", "0.5pt" ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["corner"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["inverted", xfalib.template.Constants.cornerInvertedValues, 0 ]  ,
            ["join", xfalib.template.Constants.cornerJoinValues, 0 ]  ,
            ["presence", xfalib.template.Constants.presenceValues, 0 ]  ,
            ["radius", "string", "0in" ]  ,
            ["stroke", xfalib.template.Constants.strokeValues, 0 ]  ,
            ["thickness", "string", "0.05pt" ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["toolTip"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["rid", "string", "" ]
        ]);


        XfaTemplateSchema["speak"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["disable", xfalib.template.Constants.speakDisableValues, 0 ]  ,
            ["priority", xfalib.template.Constants.speakPriorityValues, 0 ]  ,
            ["rid", "string", "" ]
        ]);


        XfaTemplateSchema["caption"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["placement", xfalib.template.Constants.captionPlacementValues, 0 ]  ,
            ["presence", xfalib.template.Constants.presenceValues, 0 ]  ,
            ["reserve", "string", "-1" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["font", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]  ,
            ["para", "zeroOrOne"]  ,
            ["value", "zeroOrOne"]
        ]);


        XfaTemplateSchema["comb"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["numberOfCells", "integer", 0 ]
        ]);


        XfaTemplateSchema["medium"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["imagingBBox", "string", "" ]  ,
            ["long", "string", "0in" ]  ,
            ["orientation", xfalib.template.Constants.orientationValues, 0 ]  ,
            ["short", "string", "0in" ]  ,
            ["stock", "string", "" ]  ,
            ["trayIn", xfalib.template.Constants.mediumTrayInValues, 0 ]  ,
            ["trayOut", xfalib.template.Constants.mediumTrayOutValues, 0 ]
        ]);


        XfaTemplateSchema["ref"] = elem = this.createElement();


        XfaTemplateSchema["pattern"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.patternTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["keep"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["intact", xfalib.template.Constants.keepIntactValues, 0 ]  ,
            ["next", xfalib.template.Constants.keepNextValues, 0 ]  ,
            ["previous", xfalib.template.Constants.keepPreviousValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["digestMethod"] = elem = this.createElement();


        XfaTemplateSchema["signing"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["certificate", "zeroOrMore"]
        ]);


        XfaTemplateSchema["encryption"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["certificate", "zeroOrMore"]
        ]);


        XfaTemplateSchema["subjectDNs"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["subjectDN", "zeroOrMore"]
        ]);


        XfaTemplateSchema["encrypt"] = elem = this.createElement();
        this.addChildren(elem, [
            ["certificate", "zeroOrOne"]
        ]);


        XfaTemplateSchema["value"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["override", xfalib.template.Constants.valueOverrideValues, 0 ]  ,
            ["relevant", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["arc", "oneOfChild"]  ,
            ["boolean", "oneOfChild"]  ,
            ["date", "oneOfChild"]  ,
            ["dateTime", "oneOfChild"]  ,
            ["decimal", "oneOfChild"]  ,
            ["exData", "oneOfChild"]  ,
            ["float", "oneOfChild"]  ,
            ["image", "oneOfChild"]  ,
            ["integer", "oneOfChild"]  ,
            ["line", "oneOfChild"]  ,
            ["rectangle", "oneOfChild"]  ,
            ["text", "oneOfChild"]  ,
            ["time", "oneOfChild"]
        ]);


        XfaTemplateSchema["traversal"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["passThrough", xfalib.template.Constants.passThroughValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["traverse", "zeroOrMore"]
        ]);


        XfaTemplateSchema["textEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["allowRichText", xfalib.template.Constants.allowRichTextValues, 0 ]  ,
            ["hScrollPolicy", xfalib.template.Constants.hScrollPolicyValues, 0 ]  ,
            ["multiLine", xfalib.template.Constants.multiLineValues, 1 ]  ,
            ["vScrollPolicy", xfalib.template.Constants.vScrollPolicyValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["comb", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["stipple"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["rate", "integer", 50 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["font"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["baselineShift", "string", "0in" ]  ,
            ["fontHorizontalScale", "string", "" ]  ,
            ["fontVerticalScale", "string", "" ]  ,
            ["kerningMode", xfalib.template.Constants.kerningModeValues, 0 ]  ,
            ["letterSpacing", "string", "" ]  ,
            ["lineThrough", xfalib.template.Constants.lineThroughValues, 0 ]  ,
            ["lineThroughPeriod", xfalib.template.Constants.lineThroughPeriodValues, 0 ]  ,
            ["overline", xfalib.template.Constants.fontOverlineValues, 0 ]  ,
            ["overlinePeriod", xfalib.template.Constants.fontOverlinePeriodValues, 0 ]  ,
            ["posture", xfalib.template.Constants.postureValues, 0 ]  ,
            ["size", "string", "10pt" ]  ,
            ["typeface", "string", "" ]  ,
            ["underline", xfalib.template.Constants.underlineValues, 0 ]  ,
            ["underlinePeriod", xfalib.template.Constants.underlinePeriodValues, 0 ]  ,
            ["weight", xfalib.template.Constants.fontWeightValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["fill", "zeroOrOne"]
        ]);


        XfaTemplateSchema["barcode"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["charEncoding", "string", "" ]  ,
            ["checksum", xfalib.template.Constants.checksumValues, 0 ]  ,
            ["dataColumnCount", "string", "" ]  ,
            ["dataLength", "string", "" ]  ,
            ["dataPrep", xfalib.template.Constants.dataPrepValues, 0 ]  ,
            ["dataRowCount", "string", "" ]  ,
            ["endChar", "string", "" ]  ,
            ["errorCorrectionLevel", "string", "" ]  ,
            ["moduleHeight", "string", "5mm" ]  ,
            ["moduleWidth", "string", "0.25mm" ]  ,
            ["printCheckDigit", xfalib.template.Constants.printCheckDigitValues, 0 ]  ,
            ["rowColumnRatio", "string", "" ]  ,
            ["startChar", "string", "" ]  ,
            ["textLocation", xfalib.template.Constants.textLocationValues, 0 ]  ,
            ["truncate", xfalib.template.Constants.truncateValues, 0 ]  ,
            ["type", "string", "" ]  ,
            ["upsMode", xfalib.template.Constants.upsModeValues, 0 ]  ,
            ["wideNarrowRatio", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["encrypt", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["assist"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["role", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["speak", "zeroOrOne"]  ,
            ["toolTip", "zeroOrOne"]
        ]);


        XfaTemplateSchema["breakBefore"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["leader", "string", "" ]  ,
            ["startNew", xfalib.template.Constants.startNewValues, 0 ]  ,
            ["target", "string", "" ]  ,
            ["targetType", xfalib.template.Constants.targetTypeValues, 0 ]  ,
            ["trailer", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["script", "zeroOrOne"]
        ]);


        XfaTemplateSchema["format"] = elem = this.createElement();
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["picture", "zeroOrOne"]
        ]);


        XfaTemplateSchema["keyUsage"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["crlSign", "string", "" ]  ,
            ["dataEncipherment", "string", "" ]  ,
            ["decipherOnly", "string", "" ]  ,
            ["digitalSignature", "string", "" ]  ,
            ["encipherOnly", "string", "" ]  ,
            ["keyAgreement", "string", "" ]  ,
            ["keyCertSign", "string", "" ]  ,
            ["keyEncipherment", "string", "" ]  ,
            ["nonRepudiation", "string", "" ]  ,
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);



        XfaTemplateSchema["picture"] = elem = this.createElement();

        XfaTemplateSchema["mdp"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["permissions", xfalib.template.Constants.mdpPermissionsValues, 0 ]  ,
            ["signatureType", xfalib.template.Constants.mdpSignatureTypeValues, 0 ]
        ]);


        XfaTemplateSchema["overflow"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["leader", "string", "" ]  ,
            ["target", "string", "" ]  ,
            ["trailer", "string", "" ]
        ]);


        XfaTemplateSchema["numericEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hScrollPolicy", xfalib.template.Constants.hScrollPolicyValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["comb", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["appearanceFilter"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);


        XfaTemplateSchema["filter"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["addRevocationInfo", "string", "" ]  ,
            ["name", "string", "" ],
            ["version", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["appearanceFilter", "zeroOrOne"]  ,
            ["certificates", "zeroOrOne"]  ,
            ["digestMethods", "zeroOrOne"]  ,
            ["encodings", "zeroOrOne"]  ,
            ["encryptionMethods", "zeroOrOne"]  ,
            ["handler", "zeroOrOne"]  ,
            ["lockDocument", "zeroOrOne"]  ,
            ["mdp", "zeroOrOne"]  ,
            ["reasons", "zeroOrOne"]  ,
            ["timeStamp", "zeroOrOne"]
        ]);


        XfaTemplateSchema["renderAs"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["APIVersion", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["svg", "zeroOrOne"]
        ]);


        XfaTemplateSchema["timeStamp"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["server", "string", "" ]  ,
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);


        XfaTemplateSchema["connect"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["connection", "string", "" ]  ,
            ["ref", "string", "" ]  ,
            ["usage", xfalib.template.Constants.connectUsageValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["picture", "zeroOrOne"]
        ]);


        XfaTemplateSchema["dateTime"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["bindItems"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["connection", "string", "" ]  ,
            ["labelRef", "string", "" ]  ,
            ["ref", "string", "" ]  ,
            ["valueRef", "string", "" ]
        ]);


        XfaTemplateSchema["encodings"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["encoding", "zeroOrMore"]
        ]);


        XfaTemplateSchema["radial"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.radialTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["certificates"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["credentialServerPolicy", xfalib.template.Constants.credentialServerPolicyValues, 0 ]  ,
            ["url", "string", "" ]  ,
            ["urlPolicy", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["encryption", "zeroOrOne"]  ,
            ["issuers", "zeroOrOne"]  ,
            ["keyUsage", "zeroOrOne"]  ,
            ["oids", "zeroOrOne"]  ,
            ["signing", "zeroOrOne"]  ,
            ["subjectDNs", "zeroOrOne"]
        ]);


        XfaTemplateSchema["svg"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["height", "string", "" ]  ,
            ["viewBox", "string", "" ]  ,
            ["width", "string", "" ]
        ]);


        XfaTemplateSchema["fill"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["presence", xfalib.template.Constants.presenceValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["linear", "oneOfChild"]  ,
            ["pattern", "oneOfChild"]  ,
            ["radial", "oneOfChild"]  ,
            ["solid", "oneOfChild"]  ,
            ["stipple", "oneOfChild"]
        ]);


        XfaTemplateSchema["setProperty"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["connection", "string", "" ]  ,
            ["ref", "string", "" ]  ,
            ["target", "string", "" ]
        ]);


        XfaTemplateSchema["encryptionMethods"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["encryptionMethod", "zeroOrMore"]
        ]);


        XfaTemplateSchema["dateTimeEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hScrollPolicy", xfalib.template.Constants.hScrollPolicyValues, 0 ]  ,
            ["picker", xfalib.template.Constants.dateTimeEditPickerValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["comb", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["message"] = elem = this.createElement();
        this.addChildren(elem, [
            ["text", "zeroOrMore"]
        ]);


        XfaTemplateSchema["color"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["cSpace", "string", "SRGB" ]  ,
            ["value", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["subjectDN"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["delimiter", "string", "" ],
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["bind"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["match", xfalib.template.Constants.bindMatchValues, 0 ]  ,
            ["ref", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["picture", "zeroOrOne"]
        ]);


        XfaTemplateSchema["handler"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);


        XfaTemplateSchema["occur"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["initial", "integer", 1 ]  ,
            ["max", "integer", 1 ]  ,
            ["min", "integer", 1 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["script", "zeroOrOne"]
        ]);

        XfaTemplateSchema["script"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["binding", "string", "" ]  ,
            ["contentType", "string", "" ]  ,
            ["name", "string", "" ],
            ["runAt", xfalib.template.Constants.runAtValues, 0 ]  ,
            ["stateless", xfalib.template.Constants.statelessValues, 0 ]
        ]);

        XfaTemplateSchema["execute"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["connection", "string", "" ]  ,
            ["executeType", xfalib.template.Constants.executeTypeValues, 0 ]  ,
            ["runAt", xfalib.template.Constants.runAtValues, 0 ]
        ]);

        XfaTemplateSchema["calculate"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["override", xfalib.template.Constants.calcOverrideValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["message", "zeroOrOne"]  ,
            ["script", "zeroOrOne"]
        ]);

        XfaTemplateSchema["submit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["embedPDF", xfalib.template.Constants.embedPDFValues, 0 ]  ,
            ["format", xfalib.template.Constants.submitFormatValues, 0 ]  ,
            ["target", "string", "" ]  ,
            ["textEncoding", "string", "" ]  ,
            ["xdpContent", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["encrypt", "zeroOrOne"]  ,
            ["encryptData", "zeroOrMore"]  ,
            ["signData", "zeroOrMore"]
        ]);

    },

    addAttributes: function(element,attrArray) {
        _.each(attrArray, function(elem) {
            element.attributes[elem[0]] = {
                                        type:elem[1],
                                        "default":elem[2]
                                       }
        });
    },

    addChildren: function(element,childrenArray) {
        _.each(childrenArray, function(elem) {
            element.children[elem[0]] = {
                relation : xfalib.template.Constants[elem[1]]
            };
        });
    },

    createElement: function() {
        return {attributes: {},children: {}};
    },

    getDefaultAttribute: function(element,attribute) {
        var elem =  XfaTemplateSchema[element];
        if(!elem)
            return "";
        var attr = elem.attributes[attribute];
        if(!attr)
            return undefined;
        if(attr.type instanceof Array) {
            return attr.type[attr["default"]];
        } else
            return attr["default"];
    },

    hasAttribute: function (element, attribute) {
        var elem = XfaTemplateSchema[element];
        if (!elem) {
            return false;
        }
        return _.has(elem.attributes, attribute);
    },

    getChildren : function(element){
        if(XfaTemplateSchema[element])
            return XfaTemplateSchema[element].children;
        else
            return null;
    },

    _getRelation: function(parent,child) {
       var p = XfaTemplateSchema[parent];
       if(!p)
          return null;
       var c = p.children[child]
       if(c)
           return c.relation;
       return null;
    },

    _getDataType: function(element,attribute) {
        var attr =  XfaTemplateSchema[element].attributes[attribute];
        return attr.type;
    },

    _getOneOfChild: function(element) {
        var res = {};
        _.each(XfaTemplateSchema[element].children,
            function(obj,clas) {
                if(obj.relation.type == "oneOfChild")
                    res[clas] = true
            });
        return res;
    }

});
})(_, xfalib);
/**
 * @package xfalib.ut.Version
 * @import xfalib.ut.Class
 */

(function(_, xfalib){
    var Version = xfalib.ut.Version = xfalib.ut.Class.extend({

        ES4: 1100,
        ES4SP1: 1101,
        P9A: 1102, //added new version for P9A -> not being used but still if we need someday

        current: function() {
            return this.P9A;
        },

        initialize : function(options){
            Version._super.initialize.call(this);
            this._originalVersion = options != null ? options.originalVersion : this.current();
            this._override = options ? options.override : {} ;
            if(!this._override) {
                this._override = {};
            }
        },


        isSame : function(v) {
            return (this._originalVersion == v);
        },

        isAfter: function(v) {
            return (this._originalVersion > v);
        },

        isAfterOrSame : function(v) {
            return this.isAfter(v) || this.isSame(v);
        },

        isPrevious: function(v) {
            return (this._originalVersion < v);
        },

        isPreviousOrSame : function(v) {
            return this.isPrevious(v) || this.isSame(v);
        },

        isOn : function(flag) {
            //function to control if a particular flag is on
            //since it might dependent on version so it is in Version class
           return(this._override[flag]);
        }

    });
})(_, xfalib);
(function(_,xfalib){
    xfalib.script.mixin.AddAssist = {
        propertyDescriptors : {
            "assist" : {
                get : function() {
                    return this.getElement("assist", 0);
                },

                set : function(value) {
                    return this.setElement(value, "assist");
                }
            }
        }
    }
})(_, xfalib);


(function(_,xfalib){
    xfalib.script.mixin.AddBorder = {
        propertyDescriptors : {
            "border" : {
                get : function() {
                    return this.getElement("border", 0);
                },

                set : function(value) {
                    return this.setElement(value, "border");
                }
            }
        }
    }
})(_, xfalib);


(function(_,xfalib){
    xfalib.script.mixin.AddCaption = {
        propertyDescriptors : {
            "caption" : {
                get : function() {
                    return this.getElement("caption", 0);
                },

                set : function(value) {
                    return this.setElement(value, "caption");
                }
            }
        }
    }
})(_, xfalib);


(function(_,xfalib){
    xfalib.script.mixin.AddPresence = {
        propertyDescriptors : {
            "presence" : {
                get : function() {
                    //Avoided getAttribute call to avoid any regression in case something is missing in Template Schema
                    return this.getOrElse(this.jsonModel.presence, xfalib.script.Node.prototype._defaults.presence);
                },
                set : function(sPresence) {
                    var oldPresence = this.jsonModel.presence;
                    this.setAttribute(sPresence, "presence");
                    if (this.jsonModel.presence != oldPresence) {
                        this._calculateEffectivePresence();
                        var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                            this,"presence",oldPresence,this.jsonModel.presence);
                        this.trigger(evnt.name,evnt);
                    }
                }
            }
        }
    }
})(_,xfalib);

(function(_,xfalib){
    xfalib.script.mixin.AddXYWH = {
        propertyDescriptors : {
            "h" : {
                get : function() {
                    return this.getOrElse(this.jsonModel.h, xfalib.script.Node.prototype._defaults.h);
                },
                set : function(value) {
                    this.setAttribute(value,"h");
                    var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                               this,"h",value, value);
                    this.trigger(event.name,event);
                }
            },

            "w" : {
                get : function() {
                    return this.getOrElse(this.jsonModel.w, xfalib.script.Node.prototype._defaults.w);
                },
                set : function() {

                }
            },

            "x" : {
                get : function() {
                    return this.getOrElse(this.jsonModel.x, xfalib.script.Node.prototype._defaults.x);
                },
                set : function() {

                }
            },

            "y" : {
                get : function() {
                    return this.getOrElse(this.jsonModel.y, xfalib.script.Node.prototype._defaults.y);
                },
                set : function() {

                }
            }
        }
    }
})(_,xfalib);

(function(_,xfalib){
    xfalib.script.mixin.AddFillColor = {
        propertyDescriptors : {
            "fillColor" : {
                get : function() {
                   return (this.border.fill.color.value == "") ? "255,255,255" : this.border.fill.color.value;
                },

                set : function(color) {
                    if(this.border && this.border.fill && this.border.fill.color) {
                        this.border.fill.presence="visible";
                        this.border.fill.color.value = color;
                    }
                }
            }
        }
    }
})(_,xfalib);
(function(_,xfalib){
    xfalib.script.mixin.AddBorderColor = {
        propertyDescriptors : {
            "borderColor" : {
                get : function() {
                    return this.border.edge.color.value;
                },

                set : function(color) {
                    //TODO: Set border.edge.presence property to visible once Border is implemented
                    this.border.edge.color.value = color ;
                }
            }
        }
    }
})(_, xfalib);

(function(_,xfalib){
    xfalib.script.mixin.AddBorderWidth = {
        propertyDescriptors : {
            "borderWidth" : {
                get : function() {
                    return this.border.edge.thickness;
                },
                set : function(value) {
                    this.border.edge.thickness = value ;
                }
            }
        }
    }
})(_, xfalib);(function(_,xfalib){
    xfalib.script.mixin.AddPara = {
        propertyDescriptors : {
            "para" : {
                get : function() {
                    return this.getElement("para", 0);
                },

                set : function(value) {
                    return this.setElement(value, "para");
                }
            }
        }
    }
})(_, xfalib);


(function(_,xfalib){
    xfalib.script.mixin.AddMargin = {
        propertyDescriptors : {
            "margin" : {
                get : function() {
                    return this.getElement("margin", 0);
                },

                set : function(value) {
                    return this.setElement(value, "margin");
                }
            }
        }
    }
})(_, xfalib);


/**
 * @package xfalib.script.Object
 * @import xfalib.ut.EventClass
 * @fileOverview The file creates the Object Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new class
     * @class Base XFA class. All the other classes are a subclass of this.
     * @constructor
     * @property {string} className represents the name of the class for this object
     */
    var xfaObject = xfalib.script.Object = xfalib.ut.EventClass.extend({
        msClassName : "object",
        initialize : function(){
            //For perf reason, we are computing className at intialize time instead of accessing it via propertyDescriptor
            this.className = this.jsonModel._class || this.msClassName;
        }
    });

})(_, xfalib);
/**
 * @package xfalib.script.XfaList
 * @import xfalib.ut.Class
 */

(function(_, xfalib){
    var XfaList = xfalib.script.XfaList = xfalib.ut.Class.extend({

        initialize : function() {
            XfaList._super.initialize.call(this);
            this.currentIndex = -1;
            this.moArraylist =  new Array();
            this.mParent = this.options.parent;
        },

        item : function(nIndex) {
            if(nIndex <= this.currentIndex)
                return this.moArraylist[nIndex];
            return null;
        },

        _append : function(oParam) {
            this.moArraylist[++this.currentIndex] = oParam;
        },

        append : function(oParam) {
            if(this.mParent && this.mParent instanceof xfalib.script.DOMElement)   {
                var relation = this.mParent._xfa()._templateSchema._getRelation(this.mParent.className,oParam.className);
                switch(relation.type)
                 {
                 case "zeroOrOne":
                 break;
                 case "zeroOrTwo":
                 break;
                 case "zeroOrMore":
                this.mParent._addChild(oParam);
                break;
                 default:

                 }

            }
            this._append(oParam);
        },

        remove : function(oParam) {
            var index = this.moArraylist.indexOf(oParam);
            if(index >= 0) {
                this.moArraylist.splice(index,1);
                this.currentIndex--;
            }
        },

        insert : function(oInsert,oBefore) {
            var index = this.moArraylist.indexOf(oBefore);
            this.currentIndex++;
            if(index <= 0)
                index = this.currentIndex;
            this.moArraylist.splice(index,0,oInsert);
        },

        _concat : function(oList) {
            if(oList == null)
                return;
            for(var i =0; i< oList.length;i++) {
                this._append(oList.item(i));
            }
        },

        namedItem : function(oParam){
            var node = this._find(function(obj) {
                return obj.getAttribute("name") === oParam;
            });
            if(node === undefined) return null;
            return node;
        },

        _find : function(fn) {
            return _.find(this.moArraylist,fn);
        },

        _filter : function(fn) {
            return _.filter(this.moArraylist,fn);
        }
    });

    XfaList.defineProps({
        "length" : {
            get : function() {
                return this.moArraylist.length;
            }
        }
    });
})(_, xfalib);

/**
 * @package xfalib.script.SOMExpression
 * @import xfalib.ut.Class
 */
 
(function(_, xfalib){
    var SOMExpression = xfalib.script.SOMExpression = xfalib.ut.Class.extend({
        initialize : function() {
            SOMExpression._super.initialize.call(this);
            // Format: subformA[n|*]
            // Format: subformA[n|*].[predicate expr]
            // Format: subformA.[predicate expr]
            // predicate expr: boolean expression that may include object references and
            // SOMExpressions

            this._expr = this.options.expression;
            this.scalerMatch = null;
            this.predicate = null;
            this.name = this.options.expression;
            this.index = this.options.defaultOccurrence;
            this._bDefaultIndex = true;
            this._matchCount = 0;

            var arr = this._parseExpression(this.options.expression);
            if (arr == null)
                return;

            if (arr.length == 1)
                this.name = arr[0];
            else if (arr.length == 2) {
                this.name = arr[0];
                if (arr[1] != '') {
                    // Strip brackets
                    var occ = arr[1].substring(1, arr[1].length - 1);
                    if (occ == '*')
                        this.index = '*';
                    else
                        this.index = parseInt(occ);

                    this._bDefaultIndex = false;
                }
            } else if (arr.length == 3) {
                this.name = arr[0];
                if (this.options.ignorePredicate == false) {
                    // Strip brackets
                    this.predicate = arr[2].substring(1, arr[2].length - 1);
                    this.index = '*';
                }
            }
        },

        equals : function(obj) {
          return this.namesEqual(obj) || this.classesEqual(obj);
        },

        evalPredicate : function (obj) {
            // Default: true, indicating obj passes pred expr qualification
            var bPredicateResult = true;

            //TODO: Implement later
            /*
             if (this.predicate != null && obj != null)
             {
             var parser:KParser = new KParser();
             var result:Object = parser.evaluateExpression (this.predicate, obj);
             if (result is Boolean)
             {
             trace ("evalPredicate() on: " + this.predicate + ", result: " + result);
             bPredicateResult = result;
             }
             }
             */
            return bPredicateResult;
        },

        namesEqual : function(obj) {
            if (this.name == obj.getAttribute("name")){
                var bPredResult = this.evalPredicate(obj);

                if (((this.index == '*') || (this.index == obj.index)) && bPredResult == true)
                    return true;

                //
                // If the SOM expression does not have a specific index
                // record a name match with the obj with the lowest index
                //
                if (this._bDefaultIndex && bPredResult)
                {
                    if ((this.scalerMatch == null) || (obj.index < this.scalerMatch.index))
                        this.scalerMatch = obj;
                }
            }
            return false;
        },

        classesEqual : function ( obj){
            var bRet = false;
            var bPredResult = this.evalPredicate(obj);

            if (this.name == "#"+obj.className){
                if (this.index == '*' && bPredResult == true){
                    bRet = true;
                }
                else{
                    if (this.index == obj.mnClassIndex && bPredResult == true)
                        bRet = true;
                    else
                        bRet = false;
                }
            }
            return bRet;
        },

        tagEquals : function (obj) {
            var parent = obj.parent;
            var max;
            if(parent) {
                try {
                    var relation = parent._getRelation(obj);
                    if(relation)
                        max = relation.max;
                }
                catch(e) {
                    this._xfa().Logger.debug("xfa", "incomplete schema.");
                }
            }
            //if this obj is the only possible child of its type then ignore class index.
            return this.name == obj.className && (max == 1 || this.index =='*' || this.index == obj.mnClassIndex)
        },

        _parseExpression : function(sSomExpression) {
            if (sSomExpression == null) {
                return null;
            }

            var arr = [];
            var buf = "";
            var inBrace = 0;
            var bEscape = false;
            for ( var j = 0; j < sSomExpression.length; j++) {
                var s = sSomExpression.charAt(j);
                if (s == "[" && !inBrace) {
                    inBrace++;
                    arr.push(buf);
                    buf = "";
                }
                if (s == "[" && inBrace) {
                    inBrace++;
                    buf += s;
                } else if (s == "]" && inBrace) {
                    --inBrace;
                    buf += s;
                } else if (s == "\\") {
                    bEscape = true;
                } else if (s == "." && !inBrace && !bEscape) {
                    arr.push(buf);
                    buf = "";
                } else {
                    buf += s;
                    bEscape = false;
                }

                if (j == sSomExpression.length - 1)
                    arr.push(buf);
            }
            return arr;
        },

        splitExpression : function(sSomExpression) {
            if (sSomExpression == null)
                return null;

            var arr = [];
            var buf = "";
            var inBrace = 0;
            var bEscape = false;
            for ( var j = 0; j < sSomExpression.length; j++) {
                var s = sSomExpression.charAt(j);
                if (s == "[") {
                    inBrace++;
                    buf += s;
                } else if (s == "]") {
                    --inBrace;
                    buf += s;
                } else if (s == "\\") {
                    bEscape = true;
                    buf += s;
                } else if (s == "." && inBrace == 0 && bEscape == false) {
                    if (buf.length == 0)
                        arr.push(".."); // elipsis
                    else {
                        if (buf.indexOf("#variables") < 0) {
                            arr.push(buf);
                        }
                    }
                    buf = "";
                } else {
                    buf += s;
                    bEscape = false;
                }

                if (j == sSomExpression.length - 1) {
                    if (buf.indexOf("#variables") < 0) {
                        arr.push(buf);
                    }
                }
            }

            if (arr.length == 1)
                return arr;

            var out = [];
            var pattern = /^\[.*\]/;
            for ( var i = 0; i < arr.length; i++) {
                var seg = String(arr[i]);
                if (seg.match(pattern) && i > 0)
                    out.splice(i - 1, 1, arr[i - 1] + "." + seg);
                else
                    out.push(arr[i]);
            }
            return out;
        }

    });

    SOMExpression.defineProps({
        "expression" : {
            get : function() {
                return this._expr;
            },
            set : function(expression) {            	
            	expression = this.validateInput(expression,"string");
                this._expr = expression;
            }
        }
    });

})(_, xfalib);



/**
 * @package xfalib.script.XfaModelEvent
 * @import xfalib.script.Object
 * @fileOverview The file creates the XfaModelEvent Class required for XFA library
 * @version 0.0.1
 */
(function(_,xfalib) {

    var XfaModelEvent = xfalib.script.XfaModelEvent = xfalib.script.Object.extend({
        msClassName: "eventPseudoModel"
    });

    XfaModelEvent.defineProps({
        "prevText" : {
            get : function(){
                return this.jsonModel.prevText;
            }
        },
        "newText" : {
            get : function(){
                return this.jsonModel.newText;
            }
        },
        "fullText": {
            get: function () {
                return this.jsonModel.fullText;
            }
        },
        "name" : {
            get : function(){
                return this.jsonModel.name;
            }
        },
        "keyDown" : {
            get : function(){
                return this.jsonModel.keyDown;
            }
        },
        "modifier" : {
            get : function(){
                return this.jsonModel.modifier;
            }
        },
        "target" : {
            get : function(){
                return this.jsonModel.target;
            }
        },
        "shift" : {
            get : function(){
                return this.jsonModel.shift;
            }
        },
        "change" : {
            get : function(){
                return this.jsonModel.change;
            },
            set : function(value){
                this.jsonModel.change = value;
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,this.target,
                    'change',value,null);
                this.target.trigger(evnt.name,evnt);
            }
        },
        "_property" : {
            get : function(){
                return this.jsonModel._property;
            },

            set : function(value){
                this.jsonModel._property = value;
            }
        }
    });

    XfaModelEvent.createEvent = function(nm,tgt,prop,oldVal,newVal) {
        var evnt = {
            name:nm,
            target:tgt,
            _property:prop,
            prevText:oldVal,
            newText:newVal
        };
        return new XfaModelEvent({"jsonModel" : evnt});
    };

    XfaModelEvent.FORM_MODEL_CHANGED = "formModelChanged";
    XfaModelEvent.RAW_VALUE_CHANGED = "rawValueChanged";
    XfaModelEvent.CHILD_ADDED = "childAdded";
    XfaModelEvent.CHILD_REMOVED = "childRemoved";
    XfaModelEvent.CHILD_MOVED = "childMoved";
    XfaModelEvent.OBJECT_DESTROYED = "objectDestroyed";
    XfaModelEvent.FORM_MODEL_REFRESH = "formModelRefresh";
    XfaModelEvent.DOM_CHANGED = "domChanged";
})(_,xfalib);
/**
 * @package xfalib.script.Layout
 * @import xfalib.script.Class
 */

(function(_, xfalib){
    var Layout = xfalib.script.Layout = xfalib.ut.Class.extend({
        initialize : function(){
            this.pagingManager = null ;
            Layout._super.initialize.call(this);

        },

        _xfa : function() {
            return xfalib.script.Xfa.Instance;
        },

        relayout: function() {
        },

        page: function(node){
            return this.pagingManager.findPage(node.htmlId) + 1;
        },

        pageCount: function() {
            if(this.pagingManager)
                return(this.pagingManager.pageCount());
        },

        absPageCount: function() {
            if(this.pagingManager)
                return(this.pagingManager.pageCount());
        },

        pageContent : function(pageNum, className, bPageArea){
            if(this.pagingManager){
                return this.pagingManager._pageContent(pageNum, className, bPageArea);
            }
            else
                return new xfalib.script.XfaList();
        },

        px2pt: function(px) {
            return px/2;
        },

        pt2inch: function(pt) {
            return pt/72;
        },

        pt2mm: function(pt) {
            return (pt*25.4)/72;
        },

        h: function(node, unit, offset) {
            if(this.pagingManager)    {
                this.pagingManager._makePageForHtmlId(node.htmlId);
                var layout = this.pagingManager.getLayout(node.htmlId);
                if(layout) {
                    var h = this.px2pt(layout.extenth) ;
                    if(unit == "inch" || unit == "in")
                        h = this.pt2inch(h);
                    if(unit == "mm")
                        h = this.pt2mm(h);
                    if(offset != undefined)
                        h= 0;
                    return h;
                }
                else return 0;

            }

        },

        w: function(node, unit, offset) {
            if(this.pagingManager)    {
                this.pagingManager._makePageForHtmlId(node.htmlId);
                var layout = this.pagingManager.getLayout(node.htmlId);
                if(layout)      {
                    var w = this.px2pt(layout.extentw) ;
                    if(unit == "inch" || unit == "in")
                        w = this.pt2inch(w);
                    if(unit == "mm")
                        w = this.pt2mm(w);
                    if(offset != undefined)
                        w= 0;
                    return w ;
                }
                else return 0;

            }
        },

        x: function(node, unit, offset) {
            if(this.pagingManager)    {
                this.pagingManager._makePageForHtmlId(node.htmlId);
                var layout = this.pagingManager.getLayout(node.htmlId);
                if(layout){
                    var x = this.px2pt(layout.extentx) ;
                    if(unit == "inch" || unit == "in")
                        x = this.pt2inch(x);
                    if(unit == "mm")
                        x = this.pt2mm(x);
                    if(offset != undefined)
                        x= 0;
                    return x;
                }
                else return 0;

            }
        },

        y: function(node, unit, offset) {
            if(this.pagingManager)    {
                this.pagingManager._makePageForHtmlId(node.htmlId);
                var layout = this.pagingManager.getLayout(node.htmlId);
                if(layout){
                    var y = this.px2pt(layout.extenty) ;
                    if(unit == "inch" || unit == "in")
                        y = this.pt2inch(y);
                    if(unit == "mm")
                        y = this.pt2mm(y);
                    if(offset != undefined)
                        y= 0;
                    return y;
                }
                else return 0;

            }
        }

    });
    Layout.defineProps({
        "ready" : {
            get : function(){
                return true;
            }
        }
    });
})(_, xfalib);

/**
 * @package xfalib.script.Node
 * @import xfalib.script.Object
 * @import xfalib.script.SOMExpression
 * @import xfalib.script.XfaList
 * @fileOverview The file creates the Node Class required for XFA library
 * @version 0.0.1
 */


(function(_, xfalib){
    var Node = xfalib.script.Node = xfalib.script.Object.extend({
        _defaults : {
            "presence" : "visible"
        },

        initialize : function(){
            Node._super.initialize.call(this);
            /**
             * @private
             * @type xfalib.script.Node
             */
            this.mParent = null;
            /**
             * @private
             * @type string
             */
            this.mnIndex = 0;
            /**
             * @private
             * @type string
             */
            this.mnClassIndex = 0;
        },

        playJson : function(pJsonModel) {
            // tabIndex should be exempted because we are already computing it in _insert Instance
            // CQ-4324970: replace default FS_DATA_SOM present in FS_EXTRAS with dataSom present in extras for repeated elements.
            this.setFsDataSom(pJsonModel);
            this.copyObject(pJsonModel, this.jsonModel, {exceptions : ["htmlId", "children","tabIndex"], keepReference : true});
        },

        setFsDataSom : function(pJsonModel) {
            if (window.FD && window.FD.isToggleEnabled("FT_FORMS-14349")) { // FORMS-10731 : don't change FS_DATA_SOM if field is not named.
                this.setFsDataSomValue(pJsonModel);
            } else {
                if (this.getAttribute("name") && this.getAttribute("name").length > 0) {
                    this.setFsDataSomValue(pJsonModel);
                }
            }
        },

        setFsDataSomValue : function(pJsonModel) {
            var fsDataSom = this.resolveNode("#extras.FS_EXTRAS.FS_DATA_SOM");
            if (fsDataSom && pJsonModel.extras && pJsonModel.extras.dataSom) {
                fsDataSom.value = pJsonModel.extras.dataSom;
            }
        },

        //TODO: REMOVE this when the actual implementation is available
        saveXML : function() {
            return "";
        },

        //TODO: REMOVE this when the actual implementation is available
        loadXML : function() {
        },

        _computeJsonDiff : function(diff_level){
            var dest = {};
            dest._class = this.className;
            if(this.jsonModel.hasOwnProperty("name")){
                dest.name = this.jsonModel.name;
            }
            var changeFound = false;
            var initialJson = this._xfa()._xfaTemplateCache.getInitialFormDomRef(this.htmlId);
            if(!initialJson)
                initialJson = this._xfa()._xfaTemplateCache.getInitialFormDomRef(this._templateId()) || {};
            var initialPropLength = _.filter(initialJson, function(value, key){
                return key !="extras";
            }, this).length;
            var jsonPropLength = _.filter(this.jsonModel, function(value, key){
                return key !="extras";
            }, this).length;

            if(jsonPropLength != initialPropLength){
                //We need to compare property sizes without 'extra' property since this is not actually part of schema
                changeFound = diff_level===0;   // only need _class and name during submission & restoreFormState
            }

            _.each(this.jsonModel, function(value, key){
                if(key === "_class" || key === "children" || key === "extras" || key == "{default}"){
                    return;
                }
                else {
                    //Note: We are assuming that any key that is present in templateJson would also be there in model json though it's value may be null/undefined
                    if(value !== initialJson[key]){
                        if(_.isArray(value)){
                            xfalib.runtime.xfa.Logger.error("xfa", "key:"+key + " has unexpected array value:"+JSON.stringify(value) + "parent:\n"+ JSON.stringify(src)) ;
                        }
                        else if(_.isObject(value)){
                            xfalib.runtime.xfa.Logger.error("xfa", "key:"+key + " has unexpected object value:"+JSON.stringify(value) + "parent:\n"+ JSON.stringify(src)) ;
                        }
                        else{
                            if (diff_level===0) {   // only need _class and name during submission & restoreFormState, rest will stripped by computeJsonDIff-s
                                dest[key] = value;
                                changeFound = true;
                            }
                        }
                    }
                }
            }, this);

            if (diff_level === 1) {
                if (this._xfa()._templateSchema.hasAttribute(this.className, 'access') &&
                    _.contains(["exclGroup", "field", "subform"], this.className)) {
                    dest.access = this.jsonModel.access;
                    changeFound = true;
                }
                if (this._xfa()._templateSchema.hasAttribute(this.className, 'presence') &&
                    _.contains(["exclGroup", "field", "items", "subform", "draw"], this.className)) {
                    dest.presence = this.jsonModel.presence;
                    changeFound = true;
                }
            }
            return {"changed" : changeFound,
                jsonDifference : dest
            };
        },

        _getSomExpression : function() {
            if (this.mParent == null)
                return "xfa[0]." + this._escapeQualifiedName();
            else
                return this.mParent.somExpression + "." + this._escapeQualifiedName();
        },

        _escapeQualifiedName : function() {
            var name = "#" + this.className,
                index = this.mnClassIndex,
                objName = this.getAttribute("name")
            if (objName.length > 0) {
                name = objName;
                index = this.index;
            }
            var qname = name + "[" + index + "]";
            return qname.replace(/\./, "\\.");
        },

        _xfa : function() {
            return xfalib.script.Xfa.Instance;
        },

        _resetData: function() {

        },

        /**
         * Evaluates the specified SOM expression, beginning with the current XML form
         * object model object, and returns the value of the object specified in the SOM
         * expression
         *
         * @function
         */
        resolveNode : function() {
            var nodes = null;
            if (arguments.length == 1)
                nodes = this._resolveNodesCommon(this, arguments[0], false, true);
            else
                nodes = this._resolveNodesCommon(arguments[0], arguments[1], false,
                    true);

            if (nodes && nodes.length > 0)
                return nodes.item(0);
            else {

                //xfa.Logger.debug("resolveNode for somExpression " + arguments[1]
                //    + " failed");
                return null;
            }
        },

        /**
         * Evaluates the specified SOM expression, beginning with the current XML form
         * object model object, and returns the value of the object specified in the SOM
         * expression
         *
         * @function
         */
        resolveNodes : function() {
            var nodes = null;
            if (arguments.length == 1)
                nodes = this._resolveNodesCommon(this, arguments[0], true, true);
            else
                nodes = this._resolveNodesCommon(arguments[0], arguments[1], true, true);
            return nodes;
        },

        _objInList: function(obj) {
            var list = new xfalib.script.XfaList();
            list._append(obj);
            return list;
        },

        _findProperty: function(oSom) {
            var arr = new xfalib.script.XfaList();
          if(oSom.index == 0) {
              //check whether som is a dynamic property
              if(this.resolveProperties && this.resolveProperties.indexOf(oSom.name) != -1)
                arr._append(this[oSom.name])
          }
          return arr;
        },

        _resolveNodesCommon : function(obj, sSomExpression, bMultiple, bFirst) {
            var arr1 = xfalib.script.SOMExpression.prototype.splitExpression(sSomExpression);
            if(arr1[0] == '$') {
                arr1.splice(0,1,this.somExpression);
                sSomExpression = arr1.join(".");
            }
            if(arr1[0].charAt(0) == '$' || arr1[0] == 'xfa' || arr1[0] == 'this') {
                var root, i = arr1[0].length + 1;
                switch(arr1[0]) {
                    case "xfa":
                    case "$xfa":
                        root = this._xfa();
                        break;
                    case "$template":
                        root = this._xfa().template
                        break;
                    case "$form":
                        root = this._xfa().form;
                        break;
                    case "this":
                        root = this._xfa()._contextNode();
                        break;
                }
                if(arr1.length == 1)
                    return this._objInList(root)
                return this._resolveNodesCommon(root,sSomExpression
                    .substr(i), bMultiple, bFirst);
            }

            var nCurrentIndex = 0;
            // TODO: Do contextNode mumbo jumbo
            if (this._xfa() && (this._xfa()._contextNode() != null))
                nCurrentIndex = this._xfa()._contextNode().index;

            var oChildren = null; // returned as either an array of single object
            var oParent = obj;
            var si = 0;
            var bRootMatch = false;

            //
            // See if the first token of the expression matches this node
            // On the first call the children are checked first
            //
            var oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[0], obj.index);
            if ((bFirst == false) && (oSOM.equals(obj) || (oSOM.scalerMatch == obj))) {
                bRootMatch = true;
                //
                // found
                //
                if ((arr1.length == 1)) {
                    //
                    // If the expression only has one token then the expression matches
                    // this node
                    //
                    if (!bMultiple) {
                        var list = new xfalib.script.XfaList();
                        list._append(obj);
                        return list;
                    }

                    oParent = obj.parent;
                    if (oParent == null) {
                        oChildren = new xfalib.script.XfaList();
                        oChildren._append(obj);
                        return oChildren;
                    }
                    si = 0;
                } else {
                    //
                    // If the expression has more than one token then start looking for
                    // a match of subsequent tokens with the children of this node.
                    //
                    si = 1;
                    oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[1], 0);
                }
            } else {
                //
                // Check for match with one of the child nodes
                //
                oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[0], nCurrentIndex);
            }

            if (obj._isContainerNode()) {
                var bElipsis = false;

                for ( var j = si; j < arr1.length; j++) {
                    if (arr1[j] == "..") {
                        bElipsis = true;
                        j++;
                        if (j == arr1.length)
                            break;
                        oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[j], 0);
                    }

                    var bLast = ((j + 1) == arr1.length);
                    oChildren = new xfalib.script.XfaList();

                    if (!(oParent instanceof xfalib.script.XfaList)) {
                        var oParentList = new xfalib.script.XfaList();
                        oParentList._append(oParent);
                        oParent = oParentList;
                    }

                    for ( var k = 0; k < oParent.length; k++) {
                        var children,
                            parent = oParent.item(k);
                        if(parent != null && parent._isContainerNode()) {
                            if (bElipsis) {
                                children = parent._findChildrenDeep(oSOM,
                                    bMultiple);
                                bElipsis = false;
                            } else {
                                children = parent._findChildren(oSOM, bMultiple);
                                if(children.length == 0) {
                                    children = parent._findProperty(oSOM);
                                }
                            }
                        }

                        oChildren._concat(children);
                    }

                    if (oChildren.length == 0) {
                        break;
                    }

                    bRootMatch = true;
                    if (bLast == false) {
                        oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[j + 1], 0);
                        oParent = oChildren;
                    }
                }
            }

            if (oChildren && (oChildren.length != 0)) {
                return oChildren;
            }

            if ((bRootMatch == true) || (obj.parent == null)) {
                if (bFirst == true) {
                    //
                    // Try again attempting to match the current node
                    //
                    return this._resolveNodesCommon(obj, sSomExpression, bMultiple,
                        false);
                }
                if (obj.parent != null)
                    return this._resolveNodesCommon(obj.parent, sSomExpression,
                        bMultiple, false);

                if (bMultiple)
                    return new xfalib.script.XfaList();

                return null;
            } else {
                //
                // try parent
                return this._resolveNodesCommon(obj.parent, sSomExpression, bMultiple,
                    false);
            }
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a container
         *          Node or not
         */
        _isContainerNode : function() {
            return false;
        },

        _isXFAContainerNode : function() {
            return false;
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a Field or not
         */
        _isField : function() {
            return false;
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a subform or
         *          not
         */
        _isSubform : function() {
            return false;
        },

        _isExclusionGroup : function() {
            return false;
        },

        _findChildren : function(oSOM, bMultiple) {
            return null;
        },

        _findChildrenDeep : function(oSOM, bMultiple) {
            return null;
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a content Node
         *          or not
         */
        _isContent : function() {
            return false;
        },

        _isEventNode : function(){
            return false;
        },

        clone : function() {
            var clonedJson = {};
            this.copyObject(this.jsonModel, clonedJson,{exceptions : ["htmlId"]} );
            var node = xfalib.script.XfaModelRegistry.prototype.createModel(clonedJson);
            return node;
        },

        nakedFieldReferences : function(nIndex, createGetterSetter,obj) {
            return;
        },

        getAttribute: function(name, bPeek) {
            var attrValue = undefined;
            //Bug#3609434 : check only for undefined
            if(name && !_.isUndefined(this.jsonModel[name])) {
                attrValue = this.jsonModel[name];
            }
            else if(bPeek !== false) {
                attrValue = this._getDefaultAttribute(name);
            } else {
                return null;
            }
            if(name == "name" && (_.isUndefined(attrValue) || _.isNull(attrValue))){
                /* LC-8150: If attrName is name and attrValue is undefined or null then we return empty string instead of null.
                * Reason being most of the code assume that every node would have name property
                * */
                attrValue = "";
            }
            return attrValue;
        },

        /*
         * conditions for putting a node in global context
         * 1. It should have a name
         * 2. Its index should match with the index provided
         *                  OR
         * 2. There should not be more than one node with the same name in its normalizedParent Bug#3594282
         */
        getNaked : function(nIndex,createGetterSetter,Obj,scope) {
            var nodeName = this.getOrElse(this.jsonModel, "name", "");
            if ((nodeName != null) && (nodeName.length != 0) && ((scope && scope.moNameArray[nodeName] == 1) || (nIndex == this.index))) {
                //TODO: keep a state whether this node was previously naked or not. If yes do nothing
                var oObject = document[nodeName];
                if ((oObject == null) || (oObject instanceof xfalib.script.Node)) {
                    if(createGetterSetter ){
                        if(Obj._private["_"+nodeName+"_"]==null || Obj._private["_"+nodeName+"_"]==undefined){
                            this._createGetterSetter(Obj, nodeName, this);
                        }
                    }
                    else
                        Obj["_"+nodeName+"_"] = Obj["_"+nodeName+"_"] || this;
                }
            }
        },

        _getNakedThis : function(){
            return this;
        },

        toJSONString : function() {
            return JSON.stringify(this.jsonModel);
        },

        /**
         * @private
         *
         * this function performs initialization for this node.
         */
        _initialize : function() {

        },

        /**
         * @private
         * @function indicate that this is a Form node (~~).
         */
        _isForm : function() {
            return false;
        },

        _destroy : function(oChild) {
            var evnt = xfalib.script.XfaModelEvent.createEvent( xfalib.script.XfaModelEvent.OBJECT_DESTROYED, this,
                'destroy', null, this);
            this.trigger(evnt.name,evnt);
            this.off();
            var prop =  "_"+this.getAttribute("name")+"_";
            if (xfalib.runtime.hasOwnProperty(prop) && typeof xfalib.runtime[prop] != "undefined")
                if (xfalib.runtime[prop].somExpression == this.somExpression)
                    xfalib.runtime[prop] = undefined;
            this._xfa()._xfaTemplateCache.removeModel(this.htmlId);
        },

        _matches : function(oNode) {
            return (oNode != null && this.somExpression == oNode.somExpression);
        },

        _setFocus : function() {
            var evnt = xfalib.script.XfaModelEvent.createEvent( xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'focus', null, this);
            this.trigger(evnt.name,evnt);
        },

        _templateRef : function(){
            return this._xfa()._xfaTemplateCache.getTemplateRef(this.getOrElse(this.jsonModel, "extras.htmlId", null));
        },

        _templateId : function(){
            return this.getOrElse(this._templateRef(), "extras.htmlId", null);
        },

        _createGetterSetter : function(container,name,obj) {
            var iName = "_" + name + "_";
            if(!container.hasOwnProperty(name)){
                Object.defineProperty(container,name,{
                    get: function() {
                        if(this._private[iName]) {
                            return this._private[iName]._getNakedThis();
                        }
                        return undefined;
                    },
                    set : function(val) {
                        var obj = this._private[iName];
                        obj[obj._default] = val;
                    }
                });
            }
            container._private[iName]=obj;
        },

        _getDefaultAttribute : function(attribute) {
            return this._xfa()._templateSchema.getDefaultAttribute(this.className, attribute);
        },

        _getDefaultElement : function(elName, index, append) {
            var relation = this._xfa()._templateSchema._getRelation(this.className, elName);
            if(relation == xfalib.template.Constants.zeroOrOne || relation == xfalib.template.Constants.oneOfChild ||
                ((relation == xfalib.template.Constants.zeroOrTwo || relation == xfalib.template.Constants.zeroOrFour) && index == 0)){
                var defaultEl = xfalib.script.XfaModelRegistry.prototype.createModel({_class : elName});
                if(defaultEl && append){
                    this._addChild(defaultEl._getNakedThis());
                }
                return defaultEl;
            }
            else
                return null;
        },

        _getDataType: function(attribute) {
            return this._xfa()._templateSchema._getDataType(this.className, attribute);
        },

        _getRelation: function(child) {
            return  this._xfa()._templateSchema._getRelation(this.className,child.className);
        },

        //this function filters the nodes based on a filterFn.
        //this processes not only immediate children but goes recursively through the whole tree
        _filterNodes:function(filterFn) {
            var nodeList = new xfalib.script.XfaList();
            if (this._isContainerNode()) {
                var children = this._getChildren();
                for(var i=0; i< children.length; i++){
                    var n = children.item(i);
                    if(filterFn(n))
                        nodeList._append(n);
                    nodeList._concat(n._filterNodes(filterFn));
                }
            }
            return nodeList;
        },

        getElement: function(className,index, bPeek) {
            index = index || 0;
            var arr = this._findChildren(xfalib.script.XfaModelRegistry.prototype.createSomExpression(className+"["+index+"]"),false);
            if(arr && arr.length >0)
                return arr.item(0);
            else if(!bPeek && (this._getOneOfChild &&  !this._getOneOfChild(true)))
                return this._getDefaultElement(className, index, true);
            else
                return null;
        },

        setElement: function(element, className,index){
            if(_.isNumber(element) || _.isBoolean(element) || _.isDate(element) || _.isString(element)){
                var childNode = this.getElement(className, index);
                if(childNode && childNode._default){
                    childNode[childNode._default] = element;
                }
            }
            return null;
        },

        setAttribute: function(value, attrName){
            this.jsonModel[attrName] = this.validateInput(value, this._getDataType(attrName),this.jsonModel[attrName]);
        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap : function(map) {
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * @param map
         * @private
         */
        _restoreDataSomMap : function (map) {

        },

        _playDataXML: function(xmlDocument, contextNode) {

        },

        generateDataXML: function(rootNode, contextNode) {

        }

    });

    Node.defineProps({
        "parent" : {
            get : function() {
                return this.mParent;
            },
            set : function(parent) {
                parent = this.validateInput(parent, "object",null);
                this.mParent = parent;
            },
            resolve:true
        },

        "name"  : {
            get : function() {
                return this.getAttribute("name");
            },
            set : function(sName) {
                //sName = this.validateInput(sName, "string");
                //this.jsonModel.name = sName;
            },
            configurable:true
        },

        "nodes" : {
            get : function() {
                if (this._isContainerNode()) {
                    return this._getChildren();
                }
                return new xfalib.script.XfaList();
            }
        },

        "index" : {
            get : function() {
                return this.mnIndex;
            },
            set : function(nIndex) {
                nIndex = this.validateInput(nIndex, "integer",this.mnIndex);
                this.mnIndex = nIndex;
            }
        },

        "somExpression" : {
            get : function() {
                return this._getSomExpression();
            },
            set : function() {
                xfalib.runtime.xfa.Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-006"],["setting SomExpression"])
                throw "unsupported operation";
            }
        },

        "isContainer" : {
            get : function() {
                return this._isXFAContainerNode();
            }
        },

        "htmlId" : {
            get : function(){
                return this.getOrElse(this.jsonModel, "extras.htmlId", null);
            },
            set : function(sHtmlId){
                this.jsonModel.extras = this.jsonModel.extras || {};
                this.jsonModel.extras.htmlId = sHtmlId;
            }
        },

        "isNull" : {
            get : function(){
                return false;
            }
        },

        "all" : {
            get : function(){
                var list = new xfalib.script.XfaList();
                var som = xfalib.script.XfaModelRegistry.prototype.createSomExpression(this.jsonModel.name+"[*]");
                try {
                    if(this.jsonModel.name)  {
                        if(this.parent)
                            return this.parent._findChildrenDeep(som, true);
                        else return list;
                    }
                    else throw "Name undefined" ;
                }
                catch(e)   {
                    console.error("Get operation all requires the node to have a name");
                }


            }
        },

        "extras" :{
            get: function() {
                return this.getElement("extras",0)
            }
        }

    });
})(_, xfalib);


/**
 * @package xfalib.script.Element
 * @import xfalib.script.Node
 * @fileOverview The file creates the Element Class required for XFA
 *               library
 * @version 0.0.2
 */

(function (_, xfalib) {
    /**
     * @class The class represents all the XFA Objects which can contain other XFA
     *        nodes inside them
     * @extends com.adobe.xfa.scripting.Node
     *
     * @property {Array} children children of the Element
     *
     * @constructor
     * @param {string}
     *            name the name of the node
     *
     * @type {*|void}
     */
    var Element = xfalib.script.Element = xfalib.script.Node.extend({

        initialize: function () {
            Element._super.initialize.call(this);
            this._moChildNodes = [];
            this.mnCurrentIndex = -1;
            this.moNameArray = new Object();
            this.moNormalizedChildren = new Array();
            this._private = {};
            this._initChildren();
        },

        _initChildren: function () {
            var children = new Array();
            var lastCreatedInstanceManager = null;

            if (this.jsonModel.children) {
                var j = 0;
                for (var i = 0; i < this.jsonModel.children.length; i++) {
                    var child = this.jsonModel.children[i];
                    var childModel = xfalib.script.XfaModelRegistry.prototype.createModel(child);
                    if (childModel instanceof xfalib.script.InstanceManager) {
                        lastCreatedInstanceManager = childModel;
                    }
                    else if (childModel instanceof xfalib.script.Subform) {
                        if (lastCreatedInstanceManager != null) {
                            if (lastCreatedInstanceManager.name.length == 0)
                                lastCreatedInstanceManager.name = "_" + childModel.name;
                            lastCreatedInstanceManager._manageChild(childModel);
                        }
                    }
                    if (childModel) {
                        children[j++] = childModel;
                    }
                }
                this.children = children;
            }
        },

        _getChildren: function (child) {
            var parent = this;
            var obj = {"parent": parent};
            var list = new xfalib.script.XfaList(obj);
            for (var i = 0; i < this.moChildNodes.length; i++) {
                list._append(this.moChildNodes[i]._getNakedThis());
            }
            return list;
        },

        /**
         * The functions adds a child to this containerNode
         *
         * @function
         * @param {node}
         *            child The child node to add to this Element
         *
         */
        _addChild: function (child) {
            if (child != null) {
                this._addChildAt(child, this.moChildNodes.length);
            }
        },

        /**
         * @private
         * @function returns true if this is a scopeless container
         *
         */
        scopeless: function () {
            return false;
        },

        //includeDomElement tells whether DOMElement should be escalated to their parent
        appendNormalizedChildren: function (oNormalizedChildren, includeDomElement) {
            var i = 0;
            for (i = 0; i < this.moChildNodes.length; i++) {
                var oChild = this.moChildNodes[i];
                if (oChild != null) {
                    //CQ-102341 : border child of unnamed subform was getting appended to parent subform
                    if(includeDomElement === true || !(oChild instanceof xfalib.script.dom.Border)) {
                        oNormalizedChildren.push(oChild);
                    }
                    var oContainer = oChild;
                    if (oContainer
                        && (oContainer._isContainerNode() && oContainer.scopeless())) {
                        oContainer.appendNormalizedChildren(oNormalizedChildren, false);
                    }
                }
            }
        },

        /**
         * @private
         *
         * adds a dynamic property to this container.
         *
         * @param sName
         *            the name of the property to be added.
         * @param oValueObject
         *            the value of the property that is added.
         * @return the 0 based index of the property name.
         */
        _addProperty: function (sName, oValueObject, createGetterSetter) {
            var nIndex = 0;
            if ((sName != null) && (sName.length > 0)) {
                if (oValueObject == null) {
                    //
                    // just reset it
                    //
                    if (this[sName])
                        this[sName] = null;
                    this.moNameArray[sName] = 0;
                } else {
                    //
                    // add it as a property also keep track of the index
                    //
                    this.moNameArray[sName] = this.moNameArray[sName] || nIndex;
                    nIndex = this.moNameArray[sName]++;
                    if (nIndex == 0 && createGetterSetter) {
                        //
                        // Only put the first instance as a property of the container
                        // don't overwrite non dynamic properties
                        //
                        this._createGetterSetter(this, sName, oValueObject);
                    }
                }
            }
            return nIndex;
        },

        normalizeChildren: function () {
            this.moNormalizedChildren = new Array();
            this.appendNormalizedChildren(this.moNormalizedChildren, true);
            var bScopeless = this.scopeless();

            if (bScopeless) {
                //
                // must scope children in the parent container
                //
                var oParent = this.parent;
                if (oParent != null)
                    oParent.normalizeChildren();
            }

            var i = 0;
            this.moNameArray = new Object();
            for (; i < this.moNormalizedChildren.length; i++) {
                var oChild = this.moNormalizedChildren[i];
                //
                // Set properties and indices based on normalized children
                //
                var createGetterSetter = this._requireGetterSetter(oChild);
                var index = this._addProperty(this.getOrElse(oChild.jsonModel, "name", ""), oChild, createGetterSetter);
                var classIndex = this._addProperty('#' + oChild.className, oChild, false);
                if (!bScopeless) {
                    //
                    // scope indexes relative to this container
                    //
                    oChild.index = index;
                    oChild.mnClassIndex = classIndex;
                }
            }
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a container
         *          Node or not
         */
        _isContainerNode: function () {
            return true;
        },

        _requireGetterSetter: function (oChild) {
            //Tests whether dynamic getter/setter should be generated for this child which happens for infinite cardinality
            var relation = this._getRelation(oChild);
            return (relation == null || relation.max == Infinity);
        },

        _findChildren: function (oSOM, bMultiple) {
            var arr = new xfalib.script.XfaList();
            var elemFound = false;
            for (var j = 0; j < this.moNormalizedChildren.length; j++) {
                var oChild = this.moNormalizedChildren[j];
                var relation = this._getRelation(oChild);
                if (oSOM.equals(oChild) || (relation && relation.max != Infinity && oSOM.tagEquals(oChild))) {
                    arr._append(oChild._getNakedThis());
                    elemFound = true;
                }
                if (elemFound && !bMultiple)
                    return arr;
                else if (elemFound && oSOM.index != '*')
                    break;
            }

            if (oSOM.scalerMatch != null) {
                if (bMultiple == false) {
                    arr._append(oSOM.scalerMatch._getNakedThis());
                    return arr;
                }
                else {
                    // arr = [];
                    // arr.length = oSOM.scalarMatch;
                }
            }

            return arr;
        },

        /**
         * @private
         *
         * like _findChildren but searches deep for a match
         */
        _findChildrenDeep: function (oSOM, bMultiple) {
            var oObject = this._findChildren(oSOM, bMultiple);
            if (oObject == null || oObject.length == 0) {
                var oChildren = this.children;
                for (var j = 0; j < oChildren.length; j++) {
                    oObject = oChildren[j]._findChildrenDeep(oSOM, bMultiple);
                    if (oObject && oObject.length > 0)
                        break;
                }
            }
            return oObject;
        },

        /**
         * @private
         *
         * get the index of the specified child.
         *
         * @param {com.adobe.xfa.scripting.Node}
         *            oNode the node of which the index is to be found.
         * @return {number} the 0 based index of the node or -1 if not found.
         */
        _getChildIndex: function (oNode) {
            return this.moChildNodes.indexOf(oNode);
        },

        /**
         * @private
         *
         * add specified child to the specified index.
         *
         * @param oNode
         *            the node to be added.
         * @param nINdex
         *            the index where the child will be inserted.
         */
        _addChildAt: function (oNode, nIndex) {
            this.moChildNodes.splice(nIndex, 0, oNode);
            this.jsonModel.children = this.jsonModel.children || [];
            this.jsonModel.children.splice(nIndex, 0, oNode.jsonModel);
            oNode.parent = this;
            this.normalizeChildren();
            this._postAddChild(oNode);
        },

        _postAddChild: function (oNode) {
            oNode._initialize();
            if (oNode instanceof xfalib.script.DOMElement || oNode instanceof xfalib.script.GenericText) {
                oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED, this);
            }
        },

        _destroy: function (oChild) {
            for (var i = 0; i < this.moChildNodes.length; i++) {
                var child = this.moChildNodes[i];
                if (child != null)
                    child._destroy();
            }
            Element._super._destroy.call(this, oChild);
        },

        _removeAll: function () {
            _.each(this.moChildNodes, function (oChild, index) {
                oChild._destroy();
            });
            this.moChildNodes = [];
            this.jsonModel.children = [];
            this.normalizeChildren();
            //ToDo add event trigger like _remove method if required
        },

        _removeChild: function (oChild) {
            oChild._destroy();
            var nIndex = this.moChildNodes.indexOf(oChild);
            this.moChildNodes.splice(nIndex, 1);
            this.jsonModel.children.splice(nIndex, 1);
            this.normalizeChildren();
            this._postRemoveChild(oChild);
        },

        _postRemoveChild: function (oChild) {
            //do nothing here
        },

        /**
         * @private
         *
         * initialize this Container Node
         */
        _initialize: function () {
            if ((this.moChildNodes == null) || (this.moChildNodes.length == 0)) {
                this.mbInitialized = true;
                return;
            }

            if (this._xfa() == null) {
                throw (xfalib.locale.LogMessages["ALC-FRM-901-003"]);
            }

            // Init this
            if (this.parent == null) {
                this.index = 0;
                //this._xfa()._pushContextNode(this);
            }

            //
            // loop through the controls that are child components of this container
            // copy into array, since moChildNodes may be modified as we initialize
            // InstanceManagers
            //

            var oChildren = this.moChildNodes;
            for (var i = 0; i < oChildren.length; i++) {
                var oNode = oChildren[i];
                if (oNode == null)
                    xfalib.runtime.xfa.Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-004"], [this.getAttribute("name"), i]);
                else
                    oNode._initialize();
            }

            this.mbInitialized = true;

        },

        playJson: function (pJsonModel) {
            /*
             * playJson assumption: The non dom elements should always maintain the structural hierarchy.
             * For dom elements, we support only value and items. rest are ignored.
             */
            Element._super.playJson.call(this, pJsonModel);
            var schemaChildren = this._xfa()._templateSchema.getChildren(this.className);
            _.each(schemaChildren, function (schemaChildProps, schemaChildTag) {
                // if schemaChildTag is a DOMelem other than items,value continue
                if (xfalib.script.dom[schemaChildTag.charAt(0).toUpperCase() + schemaChildTag.substring(1)] !== undefined // TODO : take care of those domElements with 2nd order inheritance
                    && !_.contains(["value", "items"], schemaChildTag)) {
                    return;
                }
                if (this.playJsonForElement(schemaChildTag, pJsonModel)) {   // continue if this childTag has special handling
                    return;
                }

                var relation = schemaChildProps.relation;
                var newJChildren = _.filter(_.compact(pJsonModel.children), function (jChild) {
                    return jChild._class == schemaChildTag;
                }, this);
                var oldMChildren = _.filter(this.moChildNodes, function (mChild) {
                    return mChild.className == schemaChildTag;
                }, this);
                var oneOfChildProcessed = false;

                // to merge field items having bingdItems property
                // honour saveProperty while playingJson for new and old children
                // items have zeroOrTwo relation
                if (schemaChildTag == "items" && this.getElement("#bindItems") && oldMChildren.length && newJChildren.length) {
                    var childIndex = -1,
                        newChild = null,
                        oldChild = null;
                    childIndex = _.findIndex(oldMChildren , function (oldMChild) {
                        return this.getOrElse(oldMChild, "save", 0) == 1;
                    }, this);
                    oldChild = oldMChildren.splice(childIndex, 1);
                    childIndex = _.findIndex(newJChildren , function (newJChild) {
                        return this.getOrElse(newJChild, "save", 0) == 1;
                    }, this);
                    newChild = newJChildren.splice(childIndex, 1);
                    oldChild[0].playJson(newChild[0]);  // playJson for item having save property

                    oldChild = oldMChildren.shift();
                    newChild = newJChildren.shift();
                    if (oldChild && newChild) {
                        oldChild.playJson(newChild);  //playJson for item without save property
                    }
                }

                switch (relation) {
                    case xfalib.template.Constants.zeroOrOne :
                        if (newJChildren.length > 0 && oldMChildren.length == 0) { //Addition
                            var newMChild = xfalib.script.XfaModelRegistry.prototype.createModel(newJChildren[0]);
                            this._addChild(newMChild);
                        }
                        else if (newJChildren.length == 0 && oldMChildren.length > 0) { //removal
                            this._removeChild(oldMChildren[0]);
                        }
                        else if (newJChildren.length > 0 && oldMChildren.length > 0) {
                            oldMChildren[0].playJson(newJChildren[0]);
                        }
                        break;

                    case xfalib.template.Constants.oneOfChild :
                        if (!oneOfChildProcessed && newJChildren.length > 0 && oldMChildren.length > 0) {
                            // For the time being let's assume oneOfChild type can not be modified and can not be added/removed
                            oldMChildren[0].playJson(newJChildren[0]);
                            oneOfChildProcessed = true;
                        }
                        break;

                    default :
                        _.each(oldMChildren, function (oldMChild) {
                            var newJChild = newJChildren.shift();
                            if (newJChild) {
                                oldMChild.playJson(newJChild);
                            }
                            else {
                                this._removeChild(oldMChild);
                            }
                        }, this);
                        if (newJChildren.length > 0) {
                            _.each(newJChildren, function (newJChild) {
                                var newMChild = xfalib.script.XfaModelRegistry.prototype.createModel(newJChild);
                                this._addChild(newMChild);
                            }, this);
                        }
                        break;
                }
            }, this);
        },

        playJsonForElement: function (elName, pJsonModel) {
            return false;
        },


        _computeJsonDiff: function (diff_level) {
            if (diff_level===0 && this._newChild == true) {
                return {
                    "changed": true,
                    "jsonDifference": this.jsonModel
                };
            }
            var diff = Element._super._computeJsonDiff.call(this, diff_level);
            var attrChangeFound = diff.changed;
            var dest = diff.jsonDifference;
            var initialJson = this._xfa()._xfaTemplateCache.getInitialFormDomRef(this.htmlId);
            if (!initialJson) {
                initialJson = this._xfa()._xfaTemplateCache.getInitialFormDomRef(this._templateId()) || {};
            }
            var childChangeFound = false;
            var initialJsonChildren = this.getOrElse(initialJson, "children", []);
            if (this.getOrElse(this.moChildNodes, "length", 0) != this.getOrElse(initialJsonChildren, "length", 0)) {
                childChangeFound = true;
            }
            else {
                childChangeFound = (null != _.find(this.moChildNodes, function (mChild, index) {
                    if ((mChild.className != initialJsonChildren[index]._class) || (mChild.jsonModel.name !== initialJsonChildren[index].name)) {
                        return true;
                    }
                    return false;
                }, this));
            }

            var destChildren = [];
            _.each(this.moChildNodes, function (mChild, index) {
                var childDiff = mChild._computeJsonDiff(diff_level) || {};
                if (!(diff_level>0 && _.isEmpty(childDiff.jsonDifference))) {  // skip if during submission & restoreFormState the childDiff is empty
                    destChildren.push(childDiff.jsonDifference);
                    if (!childChangeFound && childDiff.changed) {
                        childChangeFound = true;
                    }
                }
            }, this);

            if (diff_level>0 && destChildren.length == 0) { // skip if during submission  & restoreFormState no children present
                if (this.jsonModel._class !== 'form') { // except for root subform LC-9317
                    dest = undefined; // must be careful while assigning to jsonDifference, ideally should let it be {}, but this costs bytes in final json
                }
            } else {
                dest.children = destChildren;
            }

            return {"changed": childChangeFound || attrChangeFound,
                jsonDifference: dest
            };
        },

        _getOneOfChild: function (bPeek) {
            try {
                bPeek = typeof bPeek === "undefined" ? false : true;
                if (!this._oneOfChild && bPeek === false) {
                    var children = this._xfa()._templateSchema._getOneOfChild(this.className);
                    this._oneOfChild = _.find(this.moChildNodes, function (child) {
                        return child.className in children;
                    });
                    if (this._oneOfChild)
                        this._oneOfChild = this._oneOfChild._getNakedThis();
                }
                return this._oneOfChild;
            } catch (exception) {
                this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-017"], [exception, "oneOfChild", contextObj.somExpression])
            }
        },

        /**
         * Return the bind child of the current element. getElement API doesn't return the correct value in case of
         * unnamed element inside the current element
         * @returns {*}
         * @private
         */
        _getBinding: function () {
            return _.find(this.moChildNodes, function(child) {
                return child.className === "bind"
            })
        },

        /**
         * Checks whether binding is none or not. Returns false if binding is set to none, otherwise false.
         * @returns {boolean}
         */
        hasDataBinding: function () {
            var bind = this._getBinding();
            //bind = null means use name binding
            return bind == null || bind.match !== "none";
        },

        /**
         * returns dataSom for the current field
         * @returns {*}
         * @private
         */
        _getDataSom: function () {
            return this.getOrElse(this, "extras.FS_EXTRAS.FS_DATA_SOM.value", null);
        },

        /**
         * Returns true if the bindRef for the element points to an attribute otherwise false.
         * @returns {boolean}
         * @private
         */
        _isBindRefAttribute: function () {
            return 1 == this.getOrElse(this, "extras.FS_EXTRAS.IS_ATTRIBUTE.value", 0);
        },

        _convertRefToXPath: function (bindRef) {
            var $regex = /^\$\./,
                $recordRegex = /^\$record\./,
                relative,
                _bindRef,
                somArray;
            if(bindRef.match($recordRegex) != null) {
                relative = false;
                _bindRef = bindRef.replace($recordRegex, "");
            } else {
                relative = true;
                _bindRef = bindRef.replace($regex, "");
            }
            somArray = xfalib.script.SOMExpression.prototype.splitExpression(_bindRef);
            _bindRef = _.reduce(somArray, function (memo, som, indx) {
                var currentSom = xfalib.script.XfaModelRegistry.prototype.createSomExpression(som, 0),
                    index = currentSom.index;
                // index in SOM Expression starts from 0 whereas in xpath it starts from 1
                if(_.isNumber(index)) {
                    index += 1;
                }
                if(indx === somArray.length - 1 && this._isBindRefAttribute()) {
                    // only last part in the bindRef can be attribute
                    return memo + "@" + currentSom.name;
                }
                return memo + currentSom.name + "[" + index + "]/"
            }, "", this);
            //replace the last / if exists with empty string
            _bindRef = _bindRef.replace(/\/$/,"");
            return {
                relative: relative,
                bindRef: _bindRef
            };
        },

        /**
         * Returns the xpath from the bind.dataref property. removes the leading $. from the dataRef.
         * TODO: in some places the dataRef property has $record. Need to discuss that case
         * Moreover this might not be needed if XTG provides DATASOM for the subforms.
         * @returns {*}
         * @private
         */
        _getXpathFromBindRef: function () {
            var bind = this._getBinding(),
                bindRef = this.getAttribute("name"),
                $regex = /^\$\./,
                $recordRegex = /^\$record\./,
                relative = true,
                somArray;
            if(bind != null) {
                if(bind.match === "dataRef") {
                    if(bind.ref.match($recordRegex) != null) {
                        relative = false;
                        bindRef = bind.ref.replace($recordRegex, "");
                    } else {
                        relative = true;
                        bindRef = bind.ref.replace($regex, "");
                    }
                    somArray = xfalib.script.SOMExpression.prototype.splitExpression(bindRef);
                    bindRef = _.reduce(somArray, function (memo, som, indx) {
                        var currentSom = xfalib.script.XfaModelRegistry.prototype.createSomExpression(som, 0),
                            index = currentSom.index;
                        // index in SOM Expression starts from 0 whereas in xpath it starts from 1
                        if(_.isNumber(index)) {
                                index += 1;
                        }
                        if(indx === somArray.length - 1 && this._isBindRefAttribute()) {
                            // only last part in the bindRef can be attribute
                            return memo + "@" + currentSom.name;
                        }
                        return memo + currentSom.name + "[" + index + "]/"
                    }, "", this);
                    //replace the last / if exists with empty string
                    bindRef = bindRef.replace(/\/$/,"");
                    return {
                        relative: relative,
                        bindRef: bindRef
                    };
                } else if (bind.match === "global" && ["field", "exclGroup"].indexOf(this.className) !== -1) {
                    return {
                        relative: "global",
                        bindRef: this.getAttribute("name") + "[1]"
                    };
                } else if(bind.match === "once") { // for fields with patterns
                    return this._getXPathForUseNameBinding();
                }
                // bind.match === null
                return null;
            }
            //use name binding
            /** for unnamed elements, with data binding as use name, we are returning null */
            return this._getXPathForUseNameBinding();
        },

        _getXPathForUseNameBinding: function () {
            var name = this.getAttribute("name"),
                //SOM Index starts from 0 while in XPath it starts from 1
                index = this.index + 1;
            return name === "" ? null
                               : {
                                    relative: true,
                                    bindRef: name + "[" + index + "]"
                                 };
        },

        /**
         * Iterate over every child and add entry for them into the dataSOMMap. See @ Node._getDataSomMap for more details
         * @param map
         * @private
         * if map is not an object it behaves as an identity function
         */
        _getDataSomMap: function(map) {
            if(!_.isObject(map)) {
                return map;
            }
            _.each(this.moChildNodes, function (child) {
                map = child._getDataSomMap(map);
            });
            return map;
        },

        /**
         * Iterate over every child and update their values based on the entries in the map. See @ Node._getDataSomMap
         * for more details
         * @param map
         * @private
         */
        _restoreDataSomMap: function (map) {
            if(!_.isObject(map)) {
                return;
            }
            _.each(this.moChildNodes, function (child) {
                child._restoreDataSomMap(map);
            })
        },

        /**
         * Evaluates the given xpath relative to contextNode or RootNode depending upon the value of xpath.relative
         * In case it is true, xpath is evaluates relative to contextNode otherwise rootNode
         * @param xpath
         * @param contextNode
         * @param rootNode
         * @returns {*}
         * @private
         */
        _getElementsFromXpath: function(xpath, contextNode, rootNode) {
            var nodeIter,
                XMLUtils = xfalib.ut.XMLUtils,
                doc = rootNode instanceof Document ? rootNode : rootNode.ownerDocument;
            if(xpath.relative === false) {
                nodeIter = XMLUtils.evaluateXPath(xpath.bindRef, rootNode, null,
                                    XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
            }
            else if(contextNode != null) {
                nodeIter = XMLUtils.evaluateXPath(xpath.bindRef, contextNode, null,
                                    XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
            }
            return nodeIter;
        },

        _playDataXML : function (xmlDocument, contextNode, currentBindRef) {
            _.each(this.children, function(child) {
               child._playDataXML(xmlDocument, contextNode, currentBindRef);
            }, this);
        },

        /**
         * Generates the XML by appending the elements in the rootNode
         * @param rootNode The rootNode of the xml. Generally the element that maps to the root of the form
         * @param contextNode Current Node where to insert the elements in case of relative bindings
         */
        generateDataXML: function (rootNode, contextNode) {
            _.each(this.moChildNodes, function(child) {
                child.generateDataXML(rootNode, contextNode);
            });
        },

        /**
         * Returns bindRef relative to parentBindRef. If bindRef is not a child of parentBindRef, returns null
         * otherwise removes the parentBindRef string from the bindRef
         * @param parentBindRef
         * @param bindRef
         * @returns {*}
         * @private
         */
        _getRelativeXPath: function(parentBindRef, bindRef) {
           var regexp = new RegExp("^" + parentBindRef+"/");
           if(bindRef.match(regexp)) {
              return bindRef.replace(regexp,"");
           }
           return null;
        }
    });

    Element.defineProps({
        "children": {
            get: function () {
                var nodes = [];
                for (var i = 0; i < this.moChildNodes.length; i++) {
                    var child = this.moChildNodes[i];
                    if (child != null)
                        nodes.push(child);
                }
                return nodes;
            },
            set: function (moChildren) {
                moChildren = this.validateInput(moChildren, "object", null);
                this.moChildNodes = new Array(moChildren.length);
                this.jsonModel.children = [];
                for (var i = 0; i < moChildren.length; i++) {
                    this.moChildNodes[i] = moChildren[i];
                    this.moChildNodes[i].parent = this;
                    this.jsonModel.children[i] = moChildren[i].jsonModel;
                }
                this.normalizeChildren();
            }
        },

        "oneOfChild": {
            get: function () {
                return this._getOneOfChild();
            }
        },

        moChildNodes: {
            get: function () {
                return this._moChildNodes;
            },
            set: function (value) {
                this._moChildNodes = value;
            }
        }

        /*"borderWidth" : {
         get : function() {
         this._borderWidth = this._borderWidth || "0.6624 px" ;
         return (this._borderWidth);
         },

         set : function(width) {
         //TODO: Set border.edge.presence property to visible once Border is implemented
         this._borderWidth = width ;
         var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
         this,"borderWidth",null,width);
         this.trigger(evnt.name,evnt);
         }
         },      */

    });

})(_, xfalib);


(function (_, xfalib) {
    var GenericText = xfalib.script.GenericText = xfalib.script.Node.extend({
        _default: "value",
        initialize: function () {
            GenericText._super.initialize.call(this);
            this._modelChanged = false;
        },

        setAttribute: function (value, attrName) {
            GenericText._super.setAttribute.call(this, value, attrName);
            this._modelChanged = true;
        },

        _computeJsonDiff: function (diff_level) {
            /*
             * Since we do not maintain initialJson or templateJson for DOM elements, we use this approximate method to compute jsonDiff.
             * This assumes that all attr changes would happen through setAttribute API.
             * seeAlso: DOMElement and NodeValue
             */
            // must pass 'this' node as argument array to computeDomJsonDiff
            return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level>0, xfalib.ut.XfaUtil.prototype.computeDomJsonDiff, [this]);
        }

    });

    GenericText.defineProps({
        "value": {
            get: function () {
                return this.jsonModel._value;
            },
            set: function (value) {
                if (value !== this.jsonModel._value) {
                    this._modelChanged = true;
                    var oldVal = this.jsonModel._value
                    this.jsonModel._value = this.validateInput(value, "string", this.jsonModel._value);
                    var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED, this, this.className, oldVal, this.jsonModel._value);
                    this.trigger(event.name, event);
                }
            }
        }
    });

})(_, xfalib);

(function (_, xfalib) {
    var DOMElement = xfalib.script.DOMElement = xfalib.script.Element.extend({
        _default: "value",
        initialize: function () {
            DOMElement._super.initialize.call(this);
            this._normalizePending = true;
            this._childrenInitializePending = true;
            this._childModified = false;
            this._modelChanged = false;
        },

        handleEvent: function (evnt) {
            if (evnt.name == xfalib.script.XfaModelEvent.DOM_CHANGED) {
                evnt._property = this.className + "." + evnt._property;
                this.trigger(evnt.name, evnt);
            }
        },

        _initChildren: function () {
        },

        _initialize: function () {
            //do nothing
        },

        _initChildrenInternal: function () {
            var children = new Array();
            var tempNameContainer = {};
            if (this.jsonModel.children) {
                var j = 0;
                for (var i = 0; i < this.jsonModel.children.length; i++) {
                    var child = this.jsonModel.children[i];
                    var childModel = xfalib.script.XfaModelRegistry.prototype.createModel(child);
                    children[j++] = childModel;
                    childModel.parent = this;
                    childModel.on(xfalib.script.XfaModelEvent.DOM_CHANGED, this);
                    childModel._initialize();
                    if (childModel.name) {
                        var nameIndex = tempNameContainer[childModel.name] || 0;
                        childModel.index = nameIndex;
                        nameIndex++;
                        tempNameContainer[childModel.name] = nameIndex;
                    }
                    if (childModel.className) {
                        var classIndex = tempNameContainer["#" + childModel.className] || 0;
                        childModel.mnClassIndex = classIndex;
                        classIndex++;
                        tempNameContainer["#" + childModel.className] = classIndex;
                    }
                }
                this._moChildNodes = children;
            }
        },

        _getNakedThis: function () {
            if (this._normalizePending) {
                this.normalizeChildren();
                this._normalizePending = false;
            }
            return DOMElement._super._getNakedThis.call(this);
        },

        setAttribute: function (value, attrName) {
            DOMElement._super.setAttribute.call(this, value, attrName);
            this._modelChanged = true;
        },

        _postAddChild: function (oNode) {
            DOMElement._super._postAddChild.call(this, oNode);
//            if(oNode instanceof xfalib.script.DOMElement)
            //        oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED,this) ;
            this._childModified = true;
            oNode._newChild = true;
        },

        _postRemoveChild: function (oChild) {
            DOMElement._super._postRemoveChild.call(this, oChild);
            this._childModified = true;
        },

        playJson: function (pJsonModel) {
            if (_.contains(["value", "items"], this.className)) {
                xfalib.script.Element.prototype.playJson.call(this, pJsonModel);
            }
        },

        _computeJsonDiff: function (diff_level) {
            if (diff_level && diff_level != 3) {
                return {
                    "changed": false,
                    "jsonDifference": {}
                };
            } else { // not called during submission
                if (this._newChild) {
                    return {
                        "changed": true,
                        'jsonDifference': this.jsonModel
                    };
                } else {
                    /*
                     * Since we do not maintain initialJson or templateJson for DOM elements, we use this approximate method to compute jsonDiff.
                     * This assumes that all attr changes would happen through setAttribute API.
                     * seeAlso: GenericText and NodeValue
                     */
                    var selfDiff = xfalib.ut.XfaUtil.prototype.computeDomJsonDiff.call(this, this, diff_level),
                        childrenDiff = [],
                        changed = selfDiff.changed || this._childModified,
                        childChanged = false,
                        jsonDifference = selfDiff.jsonDifference;

                    _.each(this.moChildNodes, function (mChild) {
                            var childDiff = mChild._computeJsonDiff(diff_level) || {};
                            childChanged = childChanged || childDiff.changed;
                            if (childDiff.changed && !_.isEmpty(childDiff.jsonDifference)) {
                                childrenDiff.push(childDiff.jsonDifference);
                            }
                        },
                        this);
                    if (this._childModified || childChanged) {
                        jsonDifference.children = childrenDiff;
                    }

                    return {
                        "changed": changed,
                        "jsonDifference": jsonDifference
                    };
                }
            }
        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap : function (map) {
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * @param map
         * @private
         */
        _restoreDataSomMap : function (map) {

        },

        _playDataXML: function (rootNode, contextNode) {

        },

        generateDataXML: function (xmlDocument, contextNode) {

        }

    });

    DOMElement.defineProps({
        moChildNodes: {
            get: function () {
                if (this._childrenInitializePending) {
                    this._initChildrenInternal();
                    this._childrenInitializePending = false;
                }
                return this._moChildNodes;
            },
            set: function (value) {
                this._moChildNodes = value;
            }
        }

    });

})(_, xfalib);



/**
 * @package xfalib.script.ContainerNode
 * @import xfalib.script.Element
 * @fileOverview The file creates the Container Element Class required for XFA
 *               library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * @class The class represents all the XFA Objects which can contain other XFA
     *        nodes inside them
     * @extends com.adobe.xfa.scripting.Element
     *
     * @property {Array} children children of the ContainerNode
     *
     * @constructor
     * @param {string}
        *            name the name of the node
     *
     */
    var ContainerNode = xfalib.script.ContainerNode = xfalib.script.Element.extend({
        _isXFAContainerNode : function() {
            return true;
        }

    });

})(_, xfalib);


(function(_,xfalib){
    var EventContainerNode = xfalib.script.EventContainerNode = xfalib.script.ContainerNode.extend({
        _defaults : {
            "access" : "open",
            "event" : {
                "type" : "click" //ideally, this should be activity
            },
            "validate" : {
                "disableAll" : "0",
                "formatTest" : "warning",
                "nullTest" : "disabled",
                "scriptTest" : "error",
                "message" : {
                    "defaultMessage" : {
                        value: xfalib.locale.Strings.validationIssue
                    }
                }
            }
        },

        initialize : function(){
            EventContainerNode._super.initialize.call(this);
            /**
             * @private
             * @type Object
             */
            this.moEvents = {};
            /**
             * marks the event that are fired in the current script execution as true.
             *
             * @private
             * @type Object
             */
            this.mActiveEvents = {};
            this._errorText = null;
            this._mFailedValTest = null;
            this._mFailedValLevel = null; //can be warning or error
            this.dependant = [];
            this.tests= null; //must be overridden by sub classes
            /**
             * @private
             * @type string
             */
            this.mEffectiveAccess = null;
            this.mEffectivePresence = null;
            //Initialize events array
            this._addEvents();
            this._eventListener();

            this._moContext = null;  // will cache the nakedReferences for each EventContainerNode
         },

        // visit this and all child nodes recursively
        _visitAllmoChildren: function (visitor) {
            if (_.isFunction(visitor)) {
                visitor(this);
            }

            _.each(this.moChildNodes, function (child) {
                if (_.isFunction(child._visitAllmoChildren)) {
                    child._visitAllmoChildren(visitor);
                }
            });
        },


        _eventListener :function() {
            for ( var i = 0; i < this.moChildNodes.length; ++i) {
               var oNode = this.moChildNodes[i];
               if(oNode instanceof xfalib.script.DOMElement)
                  oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED,this) ;
             }
        },

        /**
         * @private
         * @function
         * @param predicateTest : function containing predicate test.
         * @param execEvent : function containing events which needs to be executed.
         * executes events on child nodes provided as execEvent.
         */
        _execEventOnChildNodes : function (childNodesFilter, execEvent) {
            if(!this._isField()){ //Ideally isField check should not be here but a short cut for now since it's the only excption.
                _.each (this.moChildNodes, function(oNode) {
                    if (childNodesFilter(oNode)) {
                        execEvent(oNode);
                    }
                });
            }
        },

        _childNodesFilter : function (oNode) {
            return oNode._isEventNode() && oNode.className != "pageSet" && oNode.presence != "inactive";
        },

        execInitialize : function () {
            function execEvent (oNode) {
                oNode.execInitialize()
            };
            this._execEventOnChildNodes(this._childNodesFilter, execEvent);
            this.execEvent("initialize");
        },

        execFormReady : function() {
            function execEvent (oNode) {
                oNode.execFormReady()
            };
            this._execEventOnChildNodes(this._childNodesFilter, execEvent);
            this.execEvent("$formready");
        },

        execLayoutReady : function() {
            function execEvent (oNode) {
                oNode.execLayoutReady()
            };
            this._execEventOnChildNodes(this._childNodesFilter, execEvent);
            this.execEvent("$layoutready");
        },

        execCalculate : function() {
            function childNodesFilter (oNode) {
                return oNode._isEventNode() && oNode.presence != "inactive";
            };
            function execEvent (oNode) {
                oNode.execCalculate()
            };
            if (!this._xfa().host.calculationsEnabled)
                return true;
            else {
                this._execEventOnChildNodes(childNodesFilter, execEvent);
            }
           this.execEvent("calculate");
        },

        execValidate : function() {
            if (!this._xfa().host.validationsEnabled)
                return true;
            var valid = true;
            if(!this._isField()){
                for ( var i = 0; i < this.moChildNodes.length; ++i) {
                    var oNode = this.moChildNodes[i];
                    if (oNode._isEventNode()){
                        if(!oNode.execValidate())
                            valid = false;
                    }
                }
            }
            valid = valid && this._validate([]);
            return valid;
        },

        execPreSubmit : function () {
            var isSubmissionAllowed = true;  // to handle the cancelAction property, which if true will prevent submission
            if(!this._isField()) {
                _.each (this.moChildNodes, function(oNode) {
                    if (oNode._isEventNode() && oNode.presence != "inactive") {
                        isSubmissionAllowed = oNode.execPreSubmit() && isSubmissionAllowed;
                    }
                });
            }
            if (this.execEvent("$formpreSubmit") == false) {
                isSubmissionAllowed = false;
            }
            return isSubmissionAllowed;
        },

        /**
         *
         * creates a scope so that all the nodes accessible from this node
         * are available to the script event and returns the previous scope
         *
         * After executing the script the scope must be reset using _resetNakedReferencesScope
         * Not doing that will result in unstable state and cause serious issues
         *
         * @private
         * @function
         */
        _createNakedReferencesScope : function() {
            var startNode = this,
                currentIndex = this.index,
                oldContext = {};

            //store the old context in order to reset it.
            _.extend(oldContext,xfalib.runtime._private);

            //TODO: optimize to check with lastNakedSubform
            if (this._moContext == null) {
                xfalib.runtime._private = {};
                while (startNode) {
                    startNode.nakedFieldReferences(currentIndex, true, xfalib.runtime);
                    currentIndex = startNode.index;
                    startNode = startNode.parent;
                }
                this._moContext = xfalib.runtime._private;    // just copy ref as we are recreating xfalib.runtime._private
            } else {
                xfalib.runtime._private = this._moContext;
            }
            return oldContext;
        },

        /**
         *
         * The function should be called after executing the script to reset the scope
         * Not doing that will result in unstable state and cause serious issues
         *
         * @private
         * @function
         */
        _resetNakedReferencesScope : function(scope) {
            xfalib.runtime._private = {};
            _.extend(xfalib.runtime._private, scope);
        },

        /**
         * @private
         * @function
         * @param {string} eventName captures the event and sends it to the {@link _eventHandler}
         */
        execEvent : function(eventName, detail) {
            if(typeof this.moEvents[eventName] === "undefined") {
                if(this._xfa().moContextNodes.length == 0) {
                    this._xfa().runCalcAndValidate();
                }
                return true;
            }
            xfalib.runtime.xfa.Logger.debug("xfa", eventName+" fired for "+this.somExpression);
            //use standard event names instead of our home made names to match what pdf returns to user
            var stdEventName = this.xfaUtil()._xtgEventName[eventName] ? this.xfaUtil()._xtgEventName[eventName] : eventName;
            switch(eventName){
                case "change":
                    if (detail===undefined)
                        var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this}});
                    else
                        var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this,
                            "prevText":detail.prevText,"newText":detail.newText,"keyDown":detail.keyDown,
                            "modifier":detail.modifier,"shift":detail.shift,"change":detail.change,"fullText":detail.fullText}});
                    break;
                case "click":
                    if (detail===undefined)
                        var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this}});
                    else
                        var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this,"modifier":detail.modifier,"shift":detail.shift}});
                    break;
                default:
                    var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this}});

            }
            xfalib.runtime.$event = $event;
            this._xfa().event = $event;
            xfalib.runtime.event = xfalib.acrobat.AcroEvent.cloneEvent($event);
            if(this.access == "protected" && eventName!=="calculate" && eventName!== "validate") {
                return;
            }
            // According to xfa spec : when a container is inactive any calculations, validations, or events it would normally generate are suppressed
            if (this.mEffectivePresence == "inactive") {
                return;
            }

            if (this.mActiveEvents[eventName]) {
                return;
            }
            this.mActiveEvents[eventName] = true;
            this._xfa()._pushContextNode(this);
            this._xfa().moContextScriptEvent = eventName;

            var oldScope = this._createNakedReferencesScope();

            var temp$ = $;
            $ = this;
            var rValue = this._eventHandler(eventName);
            $ = temp$;
            this.mActiveEvents[eventName] = false;
            this._xfa()._popContextNode();
            this._xfa().moContextScriptEvent = null;

            $event = null;
            if(this._xfa().moContextNodes.length == 0) {
                this._xfa().runCalcAndValidate();
            } else {
                this._resetNakedReferencesScope(oldScope);
            }
            return rValue;
        },

        handleDomEvent: function(evnt) {
            this.trigger(evnt.name,evnt);
        },

        handleEvent : function(event) {
            switch (event.name) {
                case xfalib.script.XfaModelEvent.OBJECT_DESTROYED:
                    return this.removeDependant(event.target);
                case xfalib.script.XfaModelEvent.DOM_CHANGED:
                      this.handleDomEvent(event)
                default:
                    //xfa.Logger.debug("event " + event.name + " not supported");
                    return false;
            }
        },

        addDependant: function(oNode) {
            if(!~this.dependant.indexOf(oNode) && oNode != this)
                this.dependant.push(oNode);
        },

        _addEvents : function() {
            var events = _.filter(this.moChildNodes, function(childModel){
               return childModel.className == "event";
            });
            if (events && events.length > 0) {
                for ( var i = 0; i < events.length; i++) {
                    var event = events[i];
                    // ref was added to support formReady and layoutReady where the event names are available as
                    //$formReady and $layoutReady (check - _xtgEventName in the class: XfaUtil.js).
                    // When we add a style to an element, designer adds a ref value of '$'
                    //which is also the default. In such a scenario the event names become $click, $change, etc. To
                    //handle this for now (without a full implementation of ref) we are removing the $ default value
                    //and setting it as $click -> click, etc. For details on ref:
                    //http://blogs.adobe.com/formfeed/2009/03/xfa_30_event_propagation.html
                    var ref = (event.ref || "");
                    if(ref == "$") ref = "";
                    var type = ref + event.activity;
                    this.moEvents[type] = this.moEvents[type] || [];
                    var eventChild = event.oneOfChild;
                    switch(eventChild.className) {
                        case "script":
                            if(eventChild.value!=null && (eventChild.runAt === "server" || eventChild.value.trim().length >0))
                                this.moEvents[type].push(new xfalib.script.ExecutableScript({"jsonModel" : eventChild.jsonModel}));
                            break;
                        case "submit":
                            this.moEvents[type].push(new xfalib.script.Submit({"jsonModel" : eventChild.jsonModel}));
                            this._xfa()._newSubmitButton(this);  //TODO: What is it
                            break;
                    }
                }
            }

            var calcChild =  _.find(this.moChildNodes, function(childModel){
                return childModel.className == "calculate";
            });
            if(calcChild) {
                var calcScr = _.find(calcChild.moChildNodes, function(childModel){
                    return childModel.className == "script";
                });
                if(calcScr) {
                    this.moEvents["calculate"] = [new xfalib.script.CalculateScript({"jsonModel" : calcScr.jsonModel})];
                }
            }

            var validChild =  _.find(this.moChildNodes, function(childModel){
                return childModel.className == "validate";
            });
            if(validChild) {
                var validScr = _.find(validChild.moChildNodes, function(childModel){
                    return childModel.className == "script";
                });
                if(validScr) {
                    this.moEvents["validate"] = [new xfalib.script.ValidateScript({"jsonModel" : validScr.jsonModel})];
                }
            }

            //is it a good idea to create behaviorConfig at the formbridge or xfalib.runtime level???
            var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);

            //To maintain backward compatibility
            if(behaviorConfig.isOn('dataDependentFloatingField') || behaviorConfig.isOn('mfDataDependentFloatingField')) {
                //this is inserted by server when a draw element contains floating fields.
                var resolveChild = _.find(this.moChildNodes, function(childModel){
                    return childModel.className == "resolve";
                });
                if (resolveChild) {
                    this.moEvents["calculate"] = [];
                    this.moEvents["calculate"].push(new xfalib.script.FloatingFieldScript());
                }
            }
        },

        /**
         * @private
         * @function
         * @param {string} eventName Event Handler function to handle events thrown
         */
        _eventHandler : function(eventName) {
            var rValue = undefined;
            switch (eventName) {
                case "validate":
                    rValue = true;
                    break;
            }
            return rValue;
        },
        /**
         * @private
         * @function
         * returns if the node is eligible for validation or not based on the presence
         */
        _isEligibleForValidation : function() {
            return this.mEffectivePresence != "inactive";
        },

        _handleDependants: function() {
            for(var i =0;i<this.dependant.length;i++) {
                this._xfa().queueCalcEvent(this.dependant[i]);
            }
        },

        _isEventNode : function(){
            return true;
        },

        removeDependant: function(oNode) {
            this.dependant = _.without(oNode);       //TODO: What is it, no second argument?
        },

        _checkTests: function(sMessages) {
            var valid = true;
            var tests = this.tests || [];
            for(var i = 0;i<tests.length;i++) {
                valid = tests[i].apply(this,arguments);
                if(!valid)
                    break;
            }
            return valid;
        },

        _scriptTest : function(sMessages) {
            var valid = true;
            var valid = this.execEvent("validate");
            if (valid === false) {
                this._mFailedValTest = "scriptTest";
                this._mFailedValLevel  = this.getOrElse(this.validate.scriptTest, this._defaults.validate.scriptTest) ;
                this._errorText = this.validationMessage;
                this._addMessage(sMessages, this._errorText, this._mFailedValLevel);
            }
            return valid;
        },

        _validate : function(sMessages) {
            var oldFailedTest = this._mFailedValTest;
            var oldValid = this._errorText ? false : true;
            this._mFailedValTest = null;
            this._mFailedValLevel = null;
            this._errorText = null;
            var childValid = true;
            if (!this._isEligibleForValidation()) {
                return true;
            }
            if (this._xfa().host.validationsEnabled) {
                for ( var i = 0; i < this.moChildNodes.length; i++) {
                    var childNode = this.moChildNodes[i];
                    if(childNode._isEventNode()) {
                        childValid = this.moChildNodes[i]._validate(sMessages) && childValid;
                    }
                }
                var valid = this._checkTests(sMessages) && childValid;
                if(valid==false) {
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,"ValidationState",
                        this._mFailedValLevel, this._errorText);
                    this.trigger(evnt.name,evnt);
                    // true indicating that previously this field is not having error
                    // false indicating that now this field is having an error
                } else {
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                        this,"ClearError",null, null);
                    this.trigger(evnt.name,evnt);
                    // false indicating that previously this field is  having error
                    // true indicating that now this field is having an error i.e. error Cleared
                }
                xfalib.ut.XfaUtil.prototype._triggerOnBridge("elementValidationStatusChanged", this, "validationStatus", !valid, valid);
                //TODO: show the error to user.
                if (this._mFailedValTest != oldFailedTest || valid != oldValid)
                    this.execEvent("validationState");
            }
            return valid;
        },

        _addMessage : function(sMessages, sMessage, sSeverity) {
            if (sMessage) {
                var oMessageObject = new Object();
                oMessageObject.message = sMessage;
                oMessageObject.severity = sSeverity;
                oMessageObject.ref = this.somExpression;
                sMessages.push(oMessageObject);
            }
        },

        _calculateEffectiveAccess : function() {
            var parentAccess = this.parent ? this.parent.mEffectiveAccess: "open"
            var newEffAccess = (this.access === "open" && parentAccess)?parentAccess :this.access;
            if(this.mEffectiveAccess != newEffAccess)
            {
                var oldVal = this.mEffectiveAccess;
                this.mEffectiveAccess = newEffAccess;
                this._updateChildrenEffectiveAccess();
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                    this,"access",oldVal,this.mEffectiveAccess);
                this.trigger(evnt.name,evnt);
            }
        },

        _updateChildrenEffectiveAccess : function() {
            if(!this._isField()){ //Ideally isField check should not be here but a short cut for now since it's the only exception.
                _.each(this.moChildNodes, function(elem) {
                    if(elem._isEventNode())
                        elem._calculateEffectiveAccess();
                })
            }
        },

        /**
         * @private
         * @function
         * calculate effective presence which is used to identify whether current node have ancestor presence inactive
         * According to XFA SPEC : A new value, inactive, is defined for the ubiquitous presence property. When applied to containers
         * this prevents the container and its contents from processing calculations, validations, and events.
         * When an outer container contains inner containers, and the outer container has a presence value that restricts its behavior,
         * the inner containers inherit the outer container’s restricted behavior regardless of their presence value.
         */
        _calculateEffectivePresence : function() {
            if (this.presence) {     // only calculate effective presence if it contains presence property
                var parentPresence = this.getOrElse(this, "parent.mEffectivePresence", "visible"),
                    newEffPresence = null;
                if (parentPresence == "inactive" ) {
                    newEffPresence = "inactive";
                } else if (parentPresence == "hidden" && this.presence != "inactive") {
                    newEffPresence = "hidden";
                } else if (parentPresence == "invisible" && this.presence == "visible") {
                    newEffPresence = "invisible";
                } else {
                    newEffPresence = this.presence;
                }
                if(this.mEffectivePresence != newEffPresence) {
                    this.mEffectivePresence = newEffPresence;
                    this._updateChildrenEffectivePresence();
                }
            } else {
                this._updateChildrenEffectivePresence();
            }
        },

        /**
         * @private
         * @function
         * calculate effective presence for child node
         */
        _updateChildrenEffectivePresence : function() {
            if(!this._isField() && this.moChildNodes){
                _.each(this.moChildNodes, function(oNode) {
                    if(oNode._isEventNode())
                        oNode._calculateEffectivePresence();
                });
            }
        },

        playJson : function(pJsonModel) {
            //Only handle special properties which has private property in model. Need a review of access property
            if (this._xfa()._templateSchema.hasAttribute(this.className, 'access')) {
                this.access = pJsonModel.access;
            }
            if (this._xfa()._templateSchema.hasAttribute(this.className, 'presence')) {
                this.presence = pJsonModel.presence; //Watson bug 3787002 : presence property changed by server side scrip
            }
            EventContainerNode._super.playJson.call(this, pJsonModel);
        },

        scopeless : function() {
            // TODO: check isArea
            return this.getAttribute("name").length == 0;
        },

        _resetData : function() {
            for ( var i = 0; i < this.moChildNodes.length; i++) {
                var oNode = this.moChildNodes[i];
                oNode._resetData();
            }
        },

        nakedFieldReferences : function(nIndex, createGetterSetter,obj) {
            for ( var i = 0; i < this.moNormalizedChildren.length; i++) {
                var oNode = this.moNormalizedChildren[i];
                if(this._requireGetterSetter(oNode))
                    oNode.getNaked(nIndex, createGetterSetter, obj,this);
            }
        },

        // return the traversal object
        getTraversalObject : function () {
            var children = this.getOrElse(this, "jsonModel.children", null),
                traversalObj = null;
            if(children) {
                traversalObj = _.find(children, function(child){ return child._class == "traversal"; });
            }
            return traversalObj;
        },

        // return NEXT/FIRST traversal object based on the operation(first/next) provided
        getNextTraversalSom : function (operation) {
            var traverse = null,
                traversalRef = null,
                traversalObj = this.getTraversalObject();
            if (traversalObj && (traverse = traversalObj.children)) {
                if (operation == xfalib.template.Constants.firstTraversal) {
                    traversalRef = _.find(traverse, function(child){ return child.operation == xfalib.template.Constants.firstTraversal});
                } else { // only first and next are supported and if no operation is mentioned then it is treated as next
                    traversalRef = _.find(traverse, function(child){ return child.operation != xfalib.template.Constants.firstTraversal});
                }
            }
            // TO DO: add handling for script in reference
            return traversalRef && this.resolveNode(traversalRef.ref) ? this.resolveNode(traversalRef.ref).somExpression : null;
        }
    });

    EventContainerNode.defineProps({
        "validate" : {
            get : function() {
                return this.getElement("validate", 0);
            },
            set : function(val) {
                return this.setElement(val,"validate");
            }
        },

        "errorText" : {
            get : function(){
                return this._errorText || "";
            }
        },

        "validationMessage" : {
            get : function() {
                var m = this.getOrElse(this.validate.message.scriptTest, this._defaults.validate.message.defaultMessage);
                return m.value;
              },
            set : function(val) {
                var nodes = this.validate.message.nodes;
                if(nodes.namedItem("scriptTest") === null) {
                    var node = this._xfa().form.createNode("text","scriptTest");
                    nodes.append(node);
                }
                this.validate.message.scriptTest.value =val;
                this.execValidate() ;
            }

        },

        "access" : {
            get : function() {
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            },
            set : function(vAccess) {
                vAccess = this.validateInput(vAccess, this._getDataType("access"), this.jsonModel.access);
                if (this.jsonModel.access != vAccess) {
                    this.jsonModel.access = vAccess;
                    this._calculateEffectiveAccess();
                }
            }
        },

        "relevant" : {
            get : function() {
                return this.getAttribute("relevant");
            },
            set : function(val) {
                val = this.validateInput(val, this._getDataType("relevant"), this.jsonModel.relevant) ;
                if (this.getAttribute("relevant") != val) {
                    this.jsonModel.relevant = val;
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                        this,"relevant",null,val);
                    this.trigger(evnt.name,evnt);
                }
            }
        },

        "desc" : {
            get : function() {
                return this.getElement("desc",0)
            }
        }

    });

})(_,xfalib);
/**
 * @package xfalib.script.Content
 * @import xfalib.script.Node	
 * @fileOverview The file creates the Content Node Class required for XFA library
 * @version 0.0.1
 */

//goog.provide('com.adobe.xfa.scripting.Content');
//
//goog.require('com.adobe.xfa.scripting.Node');

(function(_, xfalib){
    var Content = xfalib.script.Content = xfalib.script.Node.extend({
        msClassName: "content",
        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a content Node or not
         */
        _isContent : function() {
            return true;
        }
    });
})(_, xfalib);


/**
 * @package xfalib.script.NodeValue
 * @import xfalib.ut.Class
 */


(function (_, xfalib) {
    var NodeValue = xfalib.script.NodeValue = xfalib.script.Content.extend({

        _default: "value",
        initialize: function () {
            NodeValue._super.initialize.call(this);
            this.jsonModel._value = this.jsonModel._value || null;
            this._initialJsonString = JSON.stringify(this.jsonModel);
            this._modelChanged = false;
        },

        _initialize: function () {
            NodeValue._super._initialize.apply(this, arguments);
            if (this._isFieldDescendant()) {
                this._modelChanged = true;
            }

        },

        /*
         * converts a value into the designated type. null is a valid value
         * for all types. For invalid value it returns undefined
         */
        typedValue: function (val, contentType) {
            if (typeof val === "undefined")
                return undefined;
            if (val === null || val === "")
                return null;
            return val;
        },

        /*
         * returns the typed value. since we never store undefined values
         * it always returns valid value
         */
        getValue: function (contentType, skipTypeCheck) {
            if(skipTypeCheck === true) {
                return this.jsonModel._value;
            }
            return this.typedValue(this.jsonModel._value, contentType);
        },

        _storeValue: function (val, typeVal) {
            this.jsonModel._value = val;
        },

        /*
         * converts val to its typed version and if val is valid stores
         * it.
         * returns whether the new value is different from the old one.
         */
        setValue: function (val, skipTypeCheck) {
            var oldVal = this.jsonModel._value,
                typeVal = this.typedValue(val),
                retVal = false;

            if (skipTypeCheck === true || typeof typeVal !== "undefined") {
                this._storeValue(val, typeVal);
                retVal = this.typedValue(oldVal) !== typeVal;
                this._modelChanged = true;  // LC-5465 : all field's whose value is set is to be reflected in jsonDiff
            }
            return retVal;
        },

        equals: function (oVal) {
            return (this.getValue() === oVal.getValue());
        },

        _computeJsonDiff: function (diff_level) {
            /*
             * Since we do not maintain initialJson or templateJson for DOM elements, we use this approximate method to compute jsonDiff.
             * Since value API is not as simple as other DOM api, we simply compare old and new json string to check if anything has changed
             * seeAlso: DOMElement and GenericText
             */
            var jsonStr = JSON.stringify(this.jsonModel);
            var changed = (this._initialJsonString != jsonStr);
            if (this.name === "FS_DATA_SOM" && diff_level === 3) {
                changed = true;
                this._modelChanged = true;
            }
            var jsonDiff = changed ? this.jsonModel : {_class: this.className, name: this.jsonModel.name};
            if (!changed && this._modelChanged)
                jsonDiff._value = this.jsonModel._value;
            return {
                "changed": this._modelChanged,
                jsonDifference: jsonDiff
            };
        },

        _isFieldDescendant: function () {
            var grandParent = this.getOrElse(this, "parent.parent", null);
            if (grandParent && grandParent.className == "field") {
                return true;
            }
            else {
                return false;
            }

        },

        playJson: function (pJsonModel) {
            if (pJsonModel._value != this.jsonModel._value) {
                this._modelChanged = true;
            }
            NodeValue._super.playJson.apply(this, arguments);
            if (typeof pJsonModel._value == "undefined")
                this.jsonModel._value = null;
        }
    });

    NodeValue.defineProps({
        "presence": {
            get: function () { //i am not sure how to make this property undefined so just removed setters
                return undefined;
            }
        },

        "value": {
            get: function () {
                return this.getValue();
            },

            set: function (sValue) {
                this.setValue(sValue);
                var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED, this, this.className, null, this.value);
                this.trigger(event.name, event);
            }
        }

    });

})(_, xfalib);

/**
 * @package xfalib.script.ImageValue
 * @import xfalib.script.NodeValue
 */

(function (_, xfalib) {
    var ImageValue = xfalib.script.ImageValue = xfalib.script.NodeValue.extend({
        msClassName: "image"
    });
    ImageValue.defineProps({
        "href": {
            get: function () {
                return this.getAttribute("href");
            }
        }
    });
}(_, xfalib));/**
 * @package xfalib.script.TextValue
 * @import xfalib.script.NodeValue
 */

(function(_, xfalib){
    var TextValue = xfalib.script.TextValue = xfalib.script.NodeValue.extend({
        msClassName: "text",
        typedValue : function(val) {
            var tValue = TextValue._super.typedValue.call(this, val);
            if (tValue != null)
                tValue = tValue.toString();
            return tValue;
        }

    });

    TextValue.defineProps({
        "maxChars" : {
            get : function() {
                return this.getOrElse(this.jsonModel.maxChars, "0") ;
            },
            set : function(value) {
                if(value < 0 && value == parseInt(value))
                    value = "0";
                if(value >= 0 && value == parseInt(value))   {
                    this.jsonModel.maxChars = value;
                    value = (value == "0")?"255":value;
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                        this,"maxChars",value, null);
                    this.trigger(evnt.name,evnt);
                }
            }
        }
    })
})(_, xfalib);

/**
 * @package xfalib.script.ExDataValue
 * @import xfalib.script.NodeValue
 */

(function(_, xfalib, $){

    var ExDataValue = xfalib.script.ExDataValue = xfalib.script.NodeValue.extend({
        msClassName: "exData",
        initialize : function(){
            ExDataValue._super.initialize.call(this);
            this._transformToXFACompliantModel();
            this._$internalXMLDoc = null;
            this._origTmpltVal = null;
        },

        _transformToXFACompliantModel: function(){
            if(this.className === "exData" && this.jsonModel._value !== null && this.jsonModel._value.indexOf("<body xmlns=") === -1 && this.jsonModel._value.indexOf("<body") !== -1){
                var openingBodyTagIndex = this.jsonModel._value.indexOf('<');
                var endingBodyTagIndex = this.jsonModel._value.indexOf('>');
                var bodyTagString = this.jsonModel._value.substring(openingBodyTagIndex, endingBodyTagIndex+1);
                this.jsonModel._value = this.jsonModel._value.replace(bodyTagString, '<body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/" xfa:APIVersion="2.7.0.0">');
                // this.jsonModel._value = '<body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/" xfa:APIVersion="2.7.0.0">' + this.jsonModel._value + '</body>';
            }
        },

        _computeJsonDiff: function() {
            // richtext field value should not be empty string.
            if(this.jsonModel._class === "exData" && !this.jsonModel._value){
                this.jsonModel._value = JSON.parse(this._initialJsonString)._value;
                this._transformToXFACompliantModel();
            }
            return {"changed" : true,
                jsonDifference : this.jsonModel
            };
        },

        typedValue: function(val, contentType) {
            //if contentType is not passed -> derive it from contentType attribute
            if(!contentType)
                contentType = this.getAttribute("contentType");
            switch(contentType) {
                case "text/plain":
                    return ExDataValue._super.typedValue.apply(this,[val]);
                case "text/xml":
                    if(val == null || val.length == 0)
                         return null;
                    try {
                        this._$internalXMLDoc = $.parseXML(val);
                    } catch(e) {
                        this._xfa().Logger.error("Invalid XML for the field");
                        return undefined;
                    }
                    //IE 9 supports XMLSerializer
                    return XMLSerializer ? (new XMLSerializer()).serializeToString(this._$internalXMLDoc): val
                case "text/html":
                    if(!(val && xfalib.ut.XfaUtil.prototype.isHTML(val))) {
                        if(this._$internalHTML == null) {
                           this._$internalHTML = $("<body><p></p></body>");
                        }
                        this._$internalHTML.html(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(val));
                    } else {
                        var $val = $(val);
                        this._$internalHTML = $val;
                    }
                    return this._$internalHTML.text();
                default:
                    return ExDataValue._super.typedValue.apply(this,[val]);
            }
        },

        saveXML: function() {
            var prefix = '<?xml version="1.0" encoding="UTF-8"?>' +
                         '<exData contentType="text/html" xmlns="http://www.xfa.org/schema/xfa-template/3.6/">' +
                         '<body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/">',
                suffix = '</body></exData>',
                strXML = this.jsonValue;

                // TODO : use jQuery or XMLparser to do this more reliably
                if(strXML.indexOf("<body") >=0)
                    strXML = strXML.slice(strXML.indexOf(">", strXML.indexOf("<body"))+1);
                if(strXML.lastIndexOf("</body>") >=0)
                    strXML = strXML.slice(0,strXML.lastIndexOf("</body>"));

           return prefix + strXML + suffix ;
        },

        loadXML: function(strXML) {
        //TODO : add support for other params to loadXML, as of now all calls are equivalent to loadXML(x,true,true)
            var dispValue;
            if(strXML.indexOf("<body") != -1 && strXML.lastIndexOf("</body>") != -1) { // assuming a well formed valid XML string
                dispValue = strXML.slice(strXML.indexOf(">", strXML.indexOf("<body"))+1,strXML.lastIndexOf("</body>")); // get contents within <body> tags
            }
            if(this.getAttribute("contentType") == 'text/html') {
                if(dispValue.indexOf('<span>') != 0) {
                    dispValue = '<span>' + dispValue + '</span>';  // in case of multiple html elements, wrap in a span, else they overlap !!
                }

                var $internalHTML = $('<span>'+ dispValue +'</span>');
                $internalHTML.find("p").eq(0).css('display','inline');
                dispValue = $internalHTML.html();   // get the inner html with all markups

                this.jsonValue = dispValue;
            } else {
                dispValue = '<body>' + dispValue + '</body>';
                this.value = dispValue;
            }
          }
    });

    ExDataValue.defineProps({
        "jsonValue": {  // should use it to circumvent 'typedValue', which strips html tags
            get: function () {
                return this.jsonModel._value;
            },

            set: function (sValue) {
                if(_.isNull(this._origTmpltVal)) {
                    this._origTmpltVal = this.jsonModel._value;
                }
                this._modelChanged = true;  // just to be consistent & safe with 'value'

                if(sValue !== this.jsonModel._value) {
                    this.jsonModel._value = sValue;
                    var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED, this, this.className, null, sValue);
                    this.trigger(event.name, event);
                }
            }
        }
    });
})(_, xfalib, $);

/**
 * @package xfalib.script.IntegerValue
 * @import  xfalib.script.NodeValue
 */

(function(_, xfalib){
    var IntegerValue = xfalib.script.IntegerValue = xfalib.script.NodeValue.extend({
        msClassName: "integer",
        typedValue : function(val) {
            var tValue = IntegerValue._super.typedValue.call(this, val);
            if (tValue != null) {
                tValue = parseInt(tValue);
                if (isNaN(tValue))
                   tValue = undefined;
            }
            return tValue;
        }
    });
})(_, xfalib);
/**
 * @package xfalib.script.DecimalValue
 * @import xfalib.script.NodeValue
 */

(function(_, xfalib){
    var DecimalValue = xfalib.script.DecimalValue = xfalib.script.NodeValue.extend({
        msClassName: "decimal",

        typedValue : function(val) {
            var tValue = DecimalValue._super.typedValue.call(this, val);
            if (tValue) {
                tValue = parseFloat(tValue);
                if (isNaN(tValue))
                    return undefined;
                var str = tValue + '';
                var len = str.length;
                var leadD = str.indexOf(".");
                var fracD = len - leadD - 1;
                if(fracD > this.fracDigits && this.fracDigits != -1)
                    tValue = parseFloat(tValue.toFixed(this.fracDigits));
                if(leadD > this.leadDigits && this.leadDigits != -1)
                    tValue = null;
            }
            return tValue;
        }
    });

    DecimalValue.defineProps({
        "fracDigits" : {
            get : function(){
                return this.getAttribute("fracDigits")
            }
        },

        "leadDigits" : {
            get : function(){
                return this.getAttribute("leadDigits")
            }
        }
    });
})(_, xfalib);


/*
 * @package xfalib.script.FloatValue
 * @import xfalib.script.NodeValue
 */
  

(function(_, xfalib){
    var FloatValue = xfalib.script.FloatValue = xfalib.script.NodeValue.extend({

        msClassName: "float",
        typedValue : function(val) {
            var tValue = FloatValue._super.typedValue.call(this, val);
            if (tValue) {
                tValue = parseFloat(tValue);
                if (isNaN(tValue))
                    return undefined;
                
            }
            return tValue;
        }
    });
})(_, xfalib);/*
 * @package xfalib.script.DateValue
 * @import xfalib.script.NodeValue
 */


(function(_, xfalib){
    var DateValue = xfalib.script.DateValue = xfalib.script.NodeValue.extend({
        msClassName: "date",
        typedValue : function(val) {
            var tValue = DateValue._super.typedValue.call(this, val);
            if (tValue) {
                var tValueParsed = xfalib.ut.DateInfo.Parse(tValue, undefined, false);
                if (tValueParsed !== null) {
                    tValueParsed = tValueParsed.getISODate();
                }
                // if value is not correctly parsed then return the original value
                return tValueParsed ? tValueParsed : tValue;
            }
            return tValue;
        }
    });
})(_, xfalib);/**
 * @package xfalib.script.Form
 * @import xfalib.script.ContainerNode
 */

(function (_, xfalib) {
    /**
     * @class
     * <p>
     * The Form class is the implementation of the top level XFA form object.
     * </p>
     *
     * <p>
     * The form object is accessed from the xfa object as xfa.form
     * </p>
     *
     */
    var DataNode = xfalib.script.DataNode = xfalib.ut.Class.extend({
        initialize : function() {
            this.jsonModel.value = null;
            this.fields = [];
        },

        getId : function () {
            return this.jsonModel.id;
        },

        /**
         * will sync fields having same dataId (same bindref or use global)
         * @param model
         */
        addField : function (model) {
            if (this.fields.length === 0 && model.rawValue != null) { // loose check for null/undef
                this.jsonModel.value = model.rawValue; // initialize dataNode group's value to 1st hierarchically reached field
            } else {
                model.rawValue = this.jsonModel.value;
            }
            this.fields.push(model);
            model.on(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this);
        },

        handleEvent : function (evnt) {
            switch (evnt.name) {
                case xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED:
                    this.handleModelChanged(evnt);
                    break;
                default:
                    xfalib.runtime.xfa.Logger.debug("xfa", 'Unexpected  Event  "{0}" thrown in dataNode with id : "{1}" ', [evnt.name, this.jsonModel.id]);
            }
        },

        handleModelChanged : function (event) {
            if (event._property === "rawValue") {
                this._handleValueChange(event);
            }
        },

        _handleValueChange : function (event) {
            this._updateLinkedFieldsValue(event.prevText, event.target);
        },

        /**
         * will update all linked fields to the new value passed in
         * @param newValue
         * @param target
         * @private
         * @memberof DataNode
         */
        _updateLinkedFieldsValue : function (newValue, target) {
            if (newValue !== undefined && newValue != this.jsonModel.value) { // loose type coercion here for int/str
                this.jsonModel.value = newValue;

                _.each(this.fields, function (field) {
                    if (field !== target) {
                        field.off(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this); // remove listeners to prevent event throw storm
                        field.rawValue = newValue;
                        field.on(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this); // re attach listeners
                    }
                }, this);
            }
        }
    });
})(_, xfalib);
/**
 * @package xfalib.script.ExecutableScript
 * @import xfalib.ut.Class
 */


(function(_, xfalib){
    var ExecutableScript = xfalib.script.ExecutableScript = xfalib.ut.Class.extend({
        _defaults : {
            "runAt" : "client"
        },

        initialize : function(){
            ExecutableScript._super.initialize.call(this);
            this._scriptFn = null;
        },

        execute : function(contextObj, eventName) {
            // According to XFA SPEC : If the presubmit script is marked to be run only at the server, the data is sent to the server with an
            // indication that it should run the associated script before performing the rest of the processing. Client side script for presubmit
            // are executed before running validation.
            if(this.runAt == "server" && eventName != "$formpreSubmit") {
                var options = {};
                options.activity = this.xfaUtil()._xtgEventName[eventName] ? this.xfaUtil()._xtgEventName[eventName] : eventName;
                options.contextSom = contextObj.somExpression;
                contextObj._xfa().host.runServerScript(options);
            }
            else {
                return this._executeLocal(contextObj, eventName);
            }
        },

        _executeLocal :  function(contextObj, eventName) {
            try {
                this.script.call(contextObj);      // TODO : The best way will be to use `with` so that eval can also be used without modifying anything
            } catch(exception) {
                contextObj._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-002"],[eventName, contextObj.somExpression,exception.message])
            }
            return undefined;
        }

    });

    ExecutableScript.defineProps({
        "runAt" : {
            get : function(){
                return this.getOrElse(this.jsonModel.runAt, this._defaults.runAt);
            }
        },

        "script" : {
            get : function() {
                if(this._scriptFn == null) {
                    var scriptContent = this.jsonModel._value;
                    try{
                        var content = "with(this) {\n\n with(xfalib.runtime) {\n\n" + scriptContent + "\n\n}\n\n }";
                        this._scriptFn = new Function(content);
                    }catch(exception) {
                        xfalib.runtime.xfa.Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-005"],[exception.message,scriptContent]);
                        this._scriptFn = new Function("");
                    }
                }
                return this._scriptFn;
            }
        }


    });

})(_, xfalib);

/**
 * @package xfalib.script.ValidateScript
 * @import xfalib.script.ExecutableScript
 */

(function(_, xfalib){
    var ValidateScript = xfalib.script.ValidateScript = xfalib.script.ExecutableScript.extend({

        initialize : function() {
            ValidateScript._super.initialize.call(this);
        },

        evalScript: function () {
            with(this){
                with(xfalib.runtime) {
                    var __XFA_evalValidateScriptRetVal__ = eval(arguments[0]); // LC-7319 : variable names passed in 'eval' are overridden due to enclosing 'with'
                }
            }
            return __XFA_evalValidateScriptRetVal__;
        },

        _executeLocal :  function(contextObj, eventName) {
            var rValue = true;
            try {
                if(this.script)
                    rValue = this.evalScript.call(contextObj,this.script);
                if(!rValue)
                    contextObj._xfa().Logger.debug("xfa", xfalib.locale.LogMessages["ALC-FRM-901-014"],[contextObj.somExpression,this.script])
            } catch(exception) {
                contextObj._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-002"],[eventName, contextObj.somExpression,exception.message])
                rValue = true;
            }
            return rValue;
        }

    });

    ValidateScript.defineProps({
        "script" : {
            get : function() {
                return this.jsonModel._value;
            }
        }
    });

})(_, xfalib);
/**
 * @package xfalib.script.CalculateScript
 * @import xfalib.script.ValidateScript
 */
(function(_, xfalib){
    var CalculateScript = xfalib.script.CalculateScript = xfalib.script.ValidateScript.extend({

        _executeLocal :  function(contextObj, eventName) {
            var rValue ;
            if(this.script){
                // pre_process
                contextObj._xfa()._pushCalculateEventNode(contextObj);

                try {
                    contextObj.rawValue = this.evalScript.call(contextObj,this.script)
                } catch(exception) {
                    contextObj._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-002"],[eventName, contextObj.somExpression,exception.message])
                }

                // post_process
                contextObj._xfa()._popCalculateEventNode();
            }
            return rValue;
        }

    });
})(_, xfalib);
/**
 * Created with IntelliJ IDEA.
 * User: rpandey
 * Date: 11/27/13
 * Time: 10:26 AM
 */
/**
 * @package xfalib.script.FloatingFieldScript
 * @import xfalib.script.CalculateScript
 */
(function(_, xfalib){
    var FloatingFieldScript = xfalib.script.FloatingFieldScript = xfalib.script.CalculateScript.extend({
        //Do we really need new class for FloatingFieldScript just for a different error message and a different script

        _executeLocal :  function(contextObj, eventName) {
            if(contextObj._resolveFloatingField){
                // pre_process
                contextObj._xfa()._pushCalculateEventNode(contextObj);

                try {
                    //Call _resolveFloatingField in this context
                    //this hard-coding decouples the server from script function name...
                    //Now it is only at the client side we keep the name of floating fields resolver script
                    this.evalScript.call(contextObj, '_resolveFloatingField()');
                } catch(exception) {
                    contextObj._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-019"],[contextObj.somExpression])
                }

                // post_process
                contextObj._xfa()._popCalculateEventNode();

            }

            return undefined;
        }

    });
})(_, xfalib);
/**
 * @package xfalib.script.Submit
 * @import xfalib.ut.Class
 */

(function(_, xfalib){
    var Submit = xfalib.script.Submit = xfalib.ut.Class.extend({

        initialize : function() {
            Submit._super.initialize.call(this);
        },

        execute : function(obj, eventName) {
            var options = {};
            if(this.target)
                options.action = this.target;
            options.format = this.format;
            options.textEncoding = this.textEncoding;

            formBridge.submitForm(options); //TODO: remove direct dependency on FormBridge
        }

    });

    Submit.defineProps({
        format : {
            get : function(){
                return this.getOrElse(this.jsonModel.format, null);
            }
        },

        target : {
            get : function(){
                return this.getOrElse(this.jsonModel.target, null);
            }
        },

        textEncoding : {
            get : function(){
                return this.getOrElse(this.jsonModel.textEncoding, null);
            }
        }

    });
})(_, xfalib);
/**
 * @package xfalib.script.Field
 * @import xfalib.script.Node
 * @import xfalib.script.XfaModelEvent
 * @fileOverview The file creates the Field Class required for XFA library
 * @version 0.0.1
 */

(function (_, xfalib) {
    /**
     * Creates a new Field class
     *
     * @constructor
     * @param {string}
     *            name the name of the Field
     * @param {string}
     *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends xfalib.script.Node
     */
    var Field = xfalib.script.Field = xfalib.script.EventContainerNode.extend({
        _defaults: {
            "items": {
                "save": "0"
            }
        },

        "_default": "rawValue",
        initialize: function () {
            Field._super.initialize.call(this);
            this.jsonModel["{default}"] = this._getValue();
            this.tests = [this._nullTest, this._formatTest, this._scriptTest];
            if (this.jsonModel.extras && this.jsonModel.extras.dataId)
                this._xfa().createDataNode(this.jsonModel.extras.dataId, this);
            for (var i = 0; i < this.moChildNodes.length; ++i) {
                var oNode = this.moChildNodes[i];
                oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED, this);
            }
            if (this.jsonModel.id) {
                this._xfa().Logger.debug("xfa", "Added field with id :" + this.jsonModel.id)
                this._xfa()._xfaTemplateCache.idMap[this.jsonModel.id] = this;
            }

            this.editPattern = this.getOrElse(this.jsonModel, "extras.editPatternEx", null);
        },

        playJson: function (pJsonModel) {
            Field._super.playJson.call(this, pJsonModel);

            // update data node cached value
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'rawValue', this.rawValue, this.formattedValue);
            this.trigger(evnt.name, evnt);
        },

        _setPattern: function (type, patterns, callback) {
            if (patterns && patterns.length) {
                this.jsonModel.extras = this.jsonModel.extras || {};
                _.each(patterns, function (pattern, i) {
                    pattern.locale = pattern.locale || this.locale
                }, this);
                this.jsonModel.extras[type] = patterns;
                return true;
            }
            return false;
        },

        handleDomEvent: function (evnt) {
            switch (evnt._property) {
                case "format.picture":
                    var res = this._setPattern("displayPatternEx",
                        xfalib.ut.PictureUtils.parsePictureClause(evnt.newText));
                    if (res) {
                        this._showDisplayFormat();
                    }
                    break;
                case "validate.picture":
                    var res = this._setPattern("validatePatternEx",
                        xfalib.ut.PictureUtils.parsePictureClause(evnt.newText));
                    if (res) {
                        this._validate([]);
                    }
                default:
                    xfalib.script.EventContainerNode.prototype.handleDomEvent.apply(this,
                        arguments);
            }
        },

        saveXML: function () {
            return this.rawValue;
        },

        loadXML: function (val) {
            //this.rawValue = val;
        },


        addItem: function (sDisplayVal, sSaveVal) {
            //call _getDisplayItems before saving any SaveItems.
            var sItems = this._getSaveItems(true);
            var dItems = this._getDisplayItems(true);

            var saveItem = {
                "_class": "text",
                "_value": sSaveVal === undefined ? sDisplayVal : sSaveVal
            };

            sItems._addChild(xfalib.script.XfaModelRegistry.prototype.createModel(saveItem));

            var displayItem = {
                "_class": "text",
                "_value": sDisplayVal
            };

            dItems._addChild(xfalib.script.XfaModelRegistry.prototype.createModel(displayItem));

            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                this, "addItem", saveItem._value, displayItem._value);
            this.trigger(evnt.name, evnt);
        },

        _splitStringWithEscapedCommas: function (string) {
            var arr = [];
            var start = 0;
            // a negative lookup was avoided as it's not supported in rhino and IE 11
            for(var i = 0 ; i < string.length ; i++ ){
                if(string[i] === ',' && string[i-1]!== '\\' )// i-1 is safe because the commas are already delimited
                {
                    arr.push(string.substring(start, i).replace(/\\,/g, ','));
                    start = i + 1;
                }
            }
            arr.push(string.substring(start).replace(/\\,/g, ','));
            return arr;
        },

        setItems: function (string, pair) {
            pair = pair === undefined ? 1 : pair;
            var that = this;
            var val = null;
            this.clearItems();
            var array = null;
            if(string.indexOf('\\,') > -1){
                array = this._splitStringWithEscapedCommas(string);
            }
            else {
                array = string.split(',');
            }
            if (pair == 2) {
                array.forEach(function (entry, index) {
                    if (index % 2 == 1) {
                        that.addItem(elem, entry);
                        val = entry;
                    }
                    else
                        elem = entry;
                });
                if (array.length % 2)
                    that.addItem(elem);
                return true;

            }
            else if (pair == 1) {
                array.forEach(function (entry) {
                    that.addItem(entry);
                });
                return true;
            }
            else if (pair > 2)
                return  false;
            return;
        },

        clearItems: function () {
            var sItems = this._getSaveItems(false);
            var dItems = this._getDisplayItems(false);
            if (sItems)
                sItems._removeAll();
            if (dItems)
                dItems._removeAll();
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                this, "clearItems", null, null);
            this.trigger(evnt.name, evnt);
        },

        boundItem: function (sDisplayVal) {
            var dItems = this._getDisplayItems(false);
            var saveValue = null;
            _.find(dItems ? dItems.children : [],
                function (item, index) {
                    if (item.value == sDisplayVal) {
                        saveValue = this.getSaveItem(index); //This should always be present
                        return true;
                    }
                    else
                        return false;
                }, this
            );
            return saveValue;
        },

        getDisplayItem: function (nIndex) {
            var dItems = this._getDisplayItems(true);
            if (nIndex >= 0 && dItems && dItems.children.length > nIndex)
                return dItems.moChildNodes[nIndex].value;
            else
                return undefined; //Don't change
        },

        getSaveItem: function (nIndex) {
            var sItems = this._getSaveItems(true);
            if (nIndex >= 0 && sItems && sItems.children.length > nIndex)
                return sItems.moChildNodes[nIndex].value;
            else
                return undefined; //Don't change
        },

        getItemState: function (nIndex) {
            var itemValue = this.getOrElse(this.getSaveItem(nIndex), this.getDisplayItem(nIndex));
            if (itemValue !== null && itemValue !== undefined) {
                return this.rawValue == itemValue;
            }
            return null; // TODO: return null or false
        },

        setItemState: function (nIndex, bVal) {
            var itemValue = this.getOrElse(this.getSaveItem(nIndex), this.getDisplayItem(nIndex));
            if (itemValue !== null && itemValue !== undefined) {                      //TODO:Is it correct. What about Text and NumericInput?
                if (bVal)
                    this.rawValue = itemValue;
                else if (this.rawValue == itemValue)
                    this.rawValue = null;
            }
        },

        deleteItem: function (nIndex) {
            var sItems = this._getSaveItems(false);
            var dItems = this._getDisplayItems(false);
            if (nIndex >= 0 && sItems && sItems.moChildNodes.length > nIndex) //Check whether negative value of nIndex is a legal value??
                sItems._removeChild(sItems.moChildNodes[nIndex]);
            if (nIndex >= 0 && dItems && dItems.moChildNodes.length > nIndex) //Check whether negative value of nIndex is a legal value??
                dItems._removeChild(dItems.moChildNodes[nIndex]);
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                this, "deleteItem", null, nIndex);
            this.trigger(evnt.name, evnt);
        },

        execValidate: function () {
            return(this._validate([]));
        },

        nakedFieldReferences: function (nIndex, createGetterSetter, obj) {
            return;
        },

        _resetData: function (nIndex, bForce) {
            this.rawValue = this.jsonModel["{default}"];
        },

        _nullTest: function (sMessages) {
            var valid = true;
            var value = this._getValue();
            if ((value == null || value.length == 0) && this.mandatory != "disabled") {
                this._mFailedValTest = "nullTest";
                this._mFailedValLevel = this.mandatory;
                this._errorText = this.mandatoryMessage;
                this._addMessage(sMessages, this._errorText, this._mFailedValLevel);
                valid = false;
            }
            return valid;
        },

        _formatTest: function (sMessages) {
            var valid = true;
            var value = this._getValue();
            if (value)
                value += "";
            var picture = this.getOrElse(this.jsonModel,"extras.validatePatternEx", undefined);
            if (value != null && picture) {
                var retVal = this._formatValue(value, picture, 0);
                if (!retVal) {
                    this._setErrorData("formatTest", this.getOrElse(this.validate.formatTest, this._defaults.validate.formatTest), this.formatMessage);
                    this._addMessage(sMessages, this._errorText, this._mFailedValLevel);
                    valid = false;
                }
            }
            return valid;
        },

        _setErrorData: function (failedTest, failedLevel, errorText) {
            this._mFailedValTest = failedTest;
            this._mFailedValLevel = failedLevel;
            this._errorText = errorText;
        },

        _getSaveItems: function (createIfReqd) {
            var itemsList = this.
                _findChildren(xfalib.script.XfaModelRegistry.prototype.createSomExpression("items[*]"),
                true)
            var saveItems = itemsList._find(function (item, index) {
                return item.save == 1;
            });
            if (!saveItems && createIfReqd) {
                saveItems = xfalib.script.XfaModelRegistry.prototype.createModel({
                    _class: "items",
                    save: "1",
                    name: "items"
                });
                this._addChild(saveItems);
                var displayItems = itemsList._find(function (item, index) {
                    return item.save == 0;
                });
                saveItems.children = displayItems ? displayItems.moChildNodes : [];
            }
            if (saveItems)
                return saveItems;
            else
                return null;
        },

        _getDisplayItems: function (createIfReqd) {
            var itemsList = this.
                _findChildren(xfalib.script.XfaModelRegistry.prototype.createSomExpression("items[*]"),
                true)
            var displayItems = itemsList._find(function (item, index) {
                return item.save == 0;
            });
            if (!displayItems && createIfReqd) {
                displayItems = xfalib.script.XfaModelRegistry.prototype.createModel({
                    _class: "items",
                    name: "items"
                });
                this._addChild(displayItems);
                var saveItems = itemsList._find(function (item, index) {
                    return item.save == 1;
                });
                displayItems.children = saveItems ? saveItems.moChildNodes : [];
            }
            if (displayItems)
                return displayItems;
            else
                return this._getSaveItems();
        },

        _getValue: function (contentType, skipTypeCheck) {
            return this.value.oneOfChild.getValue(contentType, skipTypeCheck);
        },

        _setValue: function (sVal, skipTypeCheck) {
            return this.value.oneOfChild.setValue(sVal, skipTypeCheck);
        },

        _setHTMLValue: function(htmlStr) {
            // api to set the html value for cm use-case
            this._setValue(htmlStr, true);
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'rawValue', null, htmlStr);
            this.trigger(evnt.name, evnt);
        },

        _eventHandler: function (eventName) {
            var rValue = undefined;
            switch (eventName) {
                case "calculate":
                    if (this.moEvents["calculate"] && this.moEvents["calculate"].length > 0) {
                        rValue = this.moEvents["calculate"][0].execute(this, "calculate");
                    }
                    break;
                case "validate":
                    if (this.moEvents["validate"] && this.moEvents["validate"].length > 0) {
                        rValue = this.moEvents["validate"][0].execute(this, "validate");
                    } else
                        rValue = true;
                    break;
                case "$formpreSubmit":
                    rValue = this._preSubmitEventHandler();
                    break;
                default:
                    if (this.moEvents[eventName]) {
                        for (var i = 0; i < this.moEvents[eventName].length; i++) {
                            this.moEvents[eventName][i].execute(this, eventName);
                        }
                    }
            }
            return rValue;
        },

        _isField: function () {
            return true;
        },

        _showDisplayFormat: function () {
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'rawValue', this.rawValue, this.formattedValue);
            this.trigger(evnt.name, evnt);
        },

        _getDefaultPictureClause: function () {
            return "";
        },

        _formatValue: function (value, picture, force) {
            //testing specifically for only null and zero length string
            if (typeof value == "undefined" || value === null || value === "")
                return null;

            //force is same as bRelaxed , which is true in case of Display and false in case of parsing.
            force = force || false;
            if (picture) {
                var i = 0;
                for (; i < picture.length; i++) {
                    try {
                        var pattern = picture[i].category + "{" + picture[i].mask + "}";
                        return xfalib.ut.PictureFmt.format(value + "", pattern, picture[i].locale, force ,false);
                    } catch (exception) {
                        //continue to next pc
                    }
                }
            }
            if (force) {
                pattern = this._getDefaultPictureClause();
                try {
                    return xfalib.ut.PictureFmt.format(value + "", pattern, this.locale,force,true);
                } catch (exception) {
                    return value;
                }
            }
            return null;
        },

        _parseValue: function (value, picture) {
            if (typeof value === undefined)
                return value;

            if (picture) {
                var i = 0;
                for (; i < picture.length; i++) {
                    try {
                        var pattern = picture[i].category + "{" + picture[i].mask + "}";
                        return xfalib.ut.PictureFmt.parse(value, pattern, picture[i].locale);
                    } catch (exception) {
                        //continue to next pc
                    }
                }
            }
            pattern = this._getDefaultPictureClause();
            try {
                return xfalib.ut.PictureFmt.parse(value, pattern, this.locale);
            } catch (exception) {
                return value;
            }
        },


        _getLocale: function () {
            var obj = this;
            var locale;
            while (!locale && obj) {
                locale = obj.jsonModel.locale;
                obj = obj.parent;
            }
            locale = locale || this._xfa().defaultLocale;
            return locale;
        },

        scopeless: function () {
            return false;
        },

        _computeJsonDiff: function (diff_level) {
            //check bindings -> if it is none then this field is not needed in xml
            if (diff_level>0) {
                var bindElement = this.getElement("bind", 0, true);
                if (bindElement) {
                    if (bindElement.getAttribute("match") === "none" && diff_level === 2) {
                        return {
                            "changed": false,
                            "jsonDifference": {}
                        };
                    }
                }
            }
            return Field._super._computeJsonDiff.call(this, diff_level);
        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap : function(map) {
            if(!_.isObject(map)) {
                return map;
            }
            var datasom = this._getDataSom();
            if(datasom !== null) {
                map[datasom] = this.rawValue;
            }
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * The function does nothing if the map is not an object
         * @param map {object}
         * @private
         */
        _restoreDataSomMap : function (map) {
            if(!_.isObject(map)) {
                return;
            }
            var datasom = this._getDataSom();
            if (datasom != null && map[datasom] !== undefined) {
                this.rawValue = map[datasom];
            }
        },

        /**
         * Evaluates the given xpath relative to contextNode or RootNode depending upon the value of xpath.relative
         * In case it is true, xpath is evaluates relative to contextNode otherwise rootNode
         * For Fields, the value of xpath.relative can be "global" in which case we need to search the descendants of
         * the rootNode
         * @param xpath
         * @param contextNode
         * @param rootNode
         * @returns {*}
         * @private
         */
        _getElementsFromXpath: function(xpath, contextNode, rootNode) {
            var nodeIter,
                XMLUtils = xfalib.ut.XMLUtils,
                doc = rootNode instanceof Document ? rootNode : rootNode.ownerDocument;
            if(xpath.relative === "global") {
                nodeIter = XMLUtils.evaluateXPath("//"+xpath.bindRef, rootNode, null,
                    XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                return nodeIter;
            }
            return Field._super._getElementsFromXpath.apply(this, arguments);
        },

        _playDataXML: function(xmlDocument, contextNode, currentBindRef) {
            if(this.hasDataBinding()) {
                var xpath = this._getXpathFromBindRef(),
                    dataPattern = this.jsonModel.dataPattern,// TODO : ideally should read from bind.picture.value
                    result, node,
                    logger = this._xfa().Logger;
                if(xpath != null) {
                    result = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                    if(result != null) {
                        node = result.iterateNext();
                        if(node != null) {
                            var preFillValue = node.textContent;

                            if(_.isString(dataPattern)) {
                                var parsedPattern = xfalib.ut.PictureUtils.parsePictureClause(dataPattern);
                                if(_.isArray(parsedPattern) && parsedPattern.length === 1) {
                                    try {
                                        // CQ-4244983 : changing the formatTest condition. Cases where prefilled value
                                        // is properly formatted, value was not being parsed and the rawValue in model
                                        // was being stored in data pattern
                                        // Ex : data pattern is text{999-99-9999} and value is 123-45-6789
                                        // 1) for mobile forms rawValue being stored is 123456789
                                        // 2) for formset rawValue being stored was 123-45-6789
                                        // in case the parse is incorrect because of mismatch in data pattern and prefillValue
                                        // then there will be data loss
                                        // and if there is any exception while parsing then original value is stored.
                                         
                                        preFillValue = xfalib.ut.PictureFmt.parse(preFillValue, dataPattern);

                                        // note : numeric parse doesn't throw, but returns 0, need to take care of it later
                                    } catch (e) {
                                        // must set value to preserve prefill data on submit
                                        this._setValue(node.textContent, true);  // need to set value without type checking, for numeric field doesn't allow non numeric chars
                                        logger.warn("xfa",
                                            logger.resolveMessage(xfalib.locale.LogMessages["ALC-FRM-901-021"],
                                                [dataPattern, node.textContent, e]));
                                    }
                                } else {
                                    this._setValue(node.textContent, true);
                                    logger.warn("xfa",
                                        logger.resolveMessage(xfalib.locale.LogMessages["ALC-FRM-901-022"],
                                            [dataPattern, node.textContent]));
                                }
                            }
                            // bug in picturefmt numeric parse : cant parse patterns with ( or ), but doesnt throw, returns 0 instead
                            if (_.isString(dataPattern) &&
                                dataPattern.trim().indexOf("num") === 0 &&
                                (preFillValue == 0 && parseFloat(node.textContent.replace(/[^0-9]/g, "")) !== 0)) { // hack: if parser returns 0, and input has any non zero digit then parsing failed
                                this._setValue(node.textContent, true);
                                logger.warn("xfa",
                                    logger.resolveMessage(xfalib.locale.LogMessages["ALC-FRM-901-023"],
                                        [dataPattern, node.textContent]));
                            } else {
                                this._setValue(preFillValue);
                            }
                        }
                    } else {
                        this._resetData();
                    }
                }
            }
        },

        /**
         * Generates the XML by appending the elements in the rootNode
         * @param rootNode The rootNode of the xml. Generally the element that maps to the root of the form
         * @param contextNode Current Node where to insert the elements in case of relative bindings
         */
        generateDataXML: function (rootNode, contextNode) {
            if(this.hasDataBinding()) {
                var xpath = this._getXpathFromBindRef(),
                    relativeXPath, nodeIter, nodeList = [], result, node;
                if(xpath != null) {
                    var element = xpath.relative === false || xpath.relative === "global" ? rootNode : contextNode;
                    element = xfalib.ut.XMLUtils.createElementsFromXPath(xpath.bindRef, element, false);
                    this._appendValueInXMLElement(element);
                }
            }
        },

        _appendValueInXMLElement: function (element) {
            if(element != null) {
                element.textContent = this._getValue(null, true); // LC-3911180 : need to circumvent type check to preserve data
            }
        },

        /**
         * @private
         * @function
         * executes presubmit event scripts and check for cancelAction property
         * return false if the cancelAction property is set true
         */
        _preSubmitEventHandler : function () {
            if (this.moEvents["$formpreSubmit"] && this.moEvents["$formpreSubmit"].length > 0) {
                this.moEvents["$formpreSubmit"][0].execute(this, "$formpreSubmit");
                // If a script invoked by the pre-submit event sets $event.cancelAction, the submit action does not take place
                if (this._xfa().event.cancelAction) {
                    return false;
                }
            }
            return true;
        }

    });

    Field.defineProps({
        "locale": {
            get: function () {
                if (!this._locale)
                    this._locale = this._getLocale();
                return this._locale;
            }
        },

        "multiLine": {
            get: function () {
                return (this.ui.oneOfChild.multiLine == 1);
            }
        },

        "rawValue": {
            get: function () {
                var currentNode = this._xfa().moCalculateEventNode;
                if (currentNode != null) {
                    this.addDependant(currentNode);
                    currentNode.on(xfalib.script.XfaModelEvent.OBJECT_DESTROYED, this);
                }
                return this._getValue(null, this.value.oneOfChild.getAttribute("contentType") === "text/html");
            },
            set: function (oValue) {
                oValue = this.validateInput(oValue, "string");
                if (this.value.oneOfChild.maxChars && this.value.oneOfChild.maxChars !== "0" && oValue && this.value.oneOfChild.maxChars < oValue.length)
                    oValue = oValue.slice(0, this.value.oneOfChild.maxChars);
                var oldval = this._getValue();
                if (this._setValue(oValue, this.value.oneOfChild.getAttribute("contentType") === "text/html")) {
                    this._handleDependants();
                    this._xfa().queueValidateEvent(this);
                }
                if (oldval != oValue)
                    this._showDisplayFormat();
            }
        },

         "font": {
                    get : function() {
                        return  this.getElement("font",0);
                    } ,
                    set :function(value) {
                          this.setElement(value,"font");
                    }
                },

        "fontColor" : {
            get : function () {
                return this.getElement("font", 0).getElement("fill", 0).getElement("color", 0).value;
            },
            set : function (value) {
                this.getElement("font", 0).getElement("fill", 0).getElement("color", 0).value = value;
            }
        },

        "value" : {
            get : function() {
                return  this.getElement("value",0);
            },
            set: function () {}
        },

        //TODO: Note: Below handling should handle both multiSelect and single Selects. Need to verify this.
        "selectedIndex": {
            get: function () {
                var value = this.rawValue;
                var itemSize = this.length;
                if (itemSize >= 0) {
                    for (var i = 0; i < itemSize; i++) {
                        var selected = this.getItemState(i);
                        if (selected)
                            return i;
                    }
                }
                return -1;   //default -1
            },
            set: function (nIndex) {
                nIndex = this.validateInput(nIndex, "string");
                this._setValue(null);
                this.setItemState(nIndex, true);
            }
        },

        "length": {
            get: function () {
                var items = (this._getSaveItems(false) || this._getDisplayItems(false));
                return items ? items.moChildNodes.length : 0;
            }
        },

        "parentSubform": {
            get: function () {
                var temp = this.parent;
                while (temp && temp.className !== "subform")
                    temp = temp.parent;
                return temp;
            }
        },

        "mandatory": {
            get: function () {
                return this.getOrElse(this.validate.nullTest, this._defaults.validate.nullTest);
            },
            set: function (value) {
                if (this.validate) {
                    this.validate.nullTest = value;
                }
            }
        },

        "mandatoryMessage": {
            get: function () {
                return xfalib.ut.XfaUtil.prototype._getMandatoryMessage(this);
            },
            set: function (val) {
                var nodes = this.validate.message.nodes;
                if (nodes.namedItem("nullTest") === null) {
                    var node = this._xfa().form.createNode("text", "nullTest");
                    nodes.append(node);
                }
                this.validate.message.nullTest.value = val;
                this.execValidate();
            }
        },

        "formatMessage": {
            get: function () {
                var msg = this.getOrElse(this.validate, "message.formatTest", this._defaults.validate.message.defaultMessage);
                return msg.value;
            },
            set: function (val) {
                var nodes = this.validate.message.nodes;
                if (nodes.namedItem("formatTest") === null) {
                    var node = this._xfa().form.createNode("text", "formatTest");
                    nodes.append(node);
                }
                this.validate.message.formatTest.value = val;
                this.execValidate();
            }
        },

        "formattedValue": {
            get: function () {
                return this._formatValue(this._getValue(), this.jsonModel.extras.displayPatternEx, true);
            },
            set: function (val) {
                this.rawValue = this._parseValue(val, this.jsonModel.extras.displayPatternEx);
            }
        },

        "isNull": {
            get: function () {
                if (this._getValue() != null)
                    return false;
                else return true;
            }
        },

        "editValue": {
            get: function () {
                return this._formatValue(this._getValue(), this.jsonModel.extras.editPatternEx, true);
            }
        },

        ui: {
            get: function () {
                return this.getElement("ui", 0);
            },

            set: function (value) {
                this.setElement(value, "ui");
            }
        },

        "items": {
            get: function () {
                return this.getElement("items", 0);
            }
        },

        "calculate": {
            get: function () {
                return this.getElement("calculate", 0);
            }
        },

        "format": {
            get: function () {
                return this.getElement("format", 0);
            }
        }


    });

    Field.addMixins([
        xfalib.script.mixin.AddAssist,
        xfalib.script.mixin.AddCaption,
        xfalib.script.mixin.AddPresence,
        xfalib.script.mixin.AddXYWH,
        xfalib.script.mixin.AddFillColor,
        xfalib.script.mixin.AddBorder,
        xfalib.script.mixin.AddBorderColor,
        xfalib.script.mixin.AddBorderWidth,
        xfalib.script.mixin.AddPara,
        xfalib.script.mixin.AddMargin
    ]);

})(_, xfalib);








/**
 * @package xfalib.script.Draw
 * @import xfalib.script.Node
 * @fileOverview The file creates the Draw Class required for XFA library
 * @version 0.0.1
 */

(function (_, xfalib, $) {
    /**
     * Creates a new Draw class
     *
     * @constructor
     * @param {string}
     *            name the name of the Draw
     * @extends com.adobe.xfa.scripting.Node
     */
    var Draw = xfalib.script.Draw = xfalib.script.EventContainerNode.extend({

        _setValue: xfalib.script.Field.prototype._setValue,

        _getValue: xfalib.script.Field.prototype._getValue,

        _getFieldById: function (fieldId) {

            if (this._xfa()._xfaTemplateCache.idMap.hasOwnProperty(fieldId)) {
                //xtg uses just the name of the field to find the actual context node
                //this is a quick and dirty way to ensure index affinity
                //just to be in sync with XTG, I am using the same implementation as XFALayoutTextResolver class
                var field = this._xfa()._xfaTemplateCache.idMap[fieldId];
                var resolvedField = null;

                var bQuit = false;
                var index = 0;
                //TODO : Can we have problem in context object setting while doing index affine resolutions ?
                while (!bQuit)
                {
                    var som = field.name + '[' + index + ']';
                    //this will be done in the context of _resolveFloatingField
                    var probField = this.resolveNode(som);
                    if (!_.isEmpty(probField)) {
                        if (probField.jsonModel.id === field.jsonModel.id) {
                            bQuit = true;
                            resolvedField = probField;
                        }
                        else {
                            //keep looking
                        }
                    }
                    else { //this will not be used very often in fact I kept it just for completeness...
                        bQuit = true;
                        var nodeName = this;
                        //vdua suggests to use xfa.form..nodeName instead of _filterNodes.
                        //it takes care of index affinity also which is a bit unpredictable
                        //Let's try this in next iteration
                        var contextNodes = this._xfa().form._filterNodes(function (n) {
                            return n.name == nodeName;
                        });

                        var occurrenceToLookFor = 0;

                        for (var i = 0; i < contextNodes.length; i++) {
                            if (contextNodes.item(i) == this) {
                                occurrenceToLookFor = i;
                                break;
                            }
                        }

                        var floatingFieldNodes = this._xfa().form._filterNodes(function (n) {
                            return n.name == field.name;
                        });

                        var occurrence = 0;
                        var foundAtLeastOneMatch = false;
                        var indexOfFirstFound = 0;

                        for (var j = 0; j < floatingFieldNodes.length; j++) {
                            var probField = floatingFieldNodes.item(j);
                            if (probField.jsonModel.id == field.jsonModel.id) {
                                if (!foundAtLeastOneMatch)
                                    indexOfFirstFound = j;
                                foundAtLeastOneMatch = true;
                                if (occurrenceToLookFor == occurrence)
                                    return probField;
                                occurrence++;
                            }
                        }

                        if (foundAtLeastOneMatch)
                            return floatingFieldNodes.item(indexOfFirstFound);
                    }
                    index++;
                }
                return resolvedField;
            }
            else
                return null;
        },

        _computeJsonDiff: function (diff_level) {
            return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level === 2, xfalib.script.Node.prototype._computeJsonDiff, arguments);
        },

        playJson : function(pJsonModel) {
            //Do not do any playJson for draw children. It should not impact floating fields.
            xfalib.script.Node.prototype.playJson.apply(this, arguments);
        },

        _playDataXML: function () {

        },

        generateDataXML: function (rootNode, contextNode) {

        },

        _resolveFloatingField: function () {
            //Can we somehow store embeds and html text in Draw object and compute it over and over again
            //may we need another NodeValue type to handle it????

            if (this.value) {
                var content = this.value.oneOfChild;
                if (content.getAttribute('contentType') === 'text/html') {
                    if(_.isNull(content._origTmpltVal)){
                        content._origTmpltVal = content.jsonValue; // save original template info containing the embed tags
                    }
                    var isTextEmbeds = false,
                        that = this,
                        htmlText = content._origTmpltVal;
                    htmlText = htmlText.replaceAll("</br>","");
                    var $internalHTML = $('<span>' + htmlText + '</span>');
                    //change the top level element to span to wrap up all the <p>, because it will cause unnecessary paragraph break

                    //no null check because jQuery is cool!
                    $internalHTML.find("p").eq(0).css('display', 'inline');

                    $internalHTML.find('[xfa\\:embed]').each(function (index, span) {
                        isTextEmbeds = true;
                        var $span = $(span);
                        var embed = $span.attr('xfa:embed');
                        var embedType = $span.attr('xfa:embedType');
                        var embedMode = $span.attr('xfa:embedMode');
                        if (embed && embed.length > 1 && embed[0] == '#') {
                            embed = embed.substr(1);
                            //resolve Node will take care of index affinity here
                            var field = (embedType == 'uri') ? that._getFieldById(embed) : that.resolveNode(embed);
                            if (field) {
                                if (embedMode === 'raw') {
                                    if (field.rawValue == null)
                                        $span.replaceWith(field.rawValue);
                                    else
                                        $span.replaceWith($.parseHTML(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(field.rawValue.toString())));
                                }
                                else
                                    $span.replaceWith(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(field.formattedValue.toString()));
                            }
                            else {
                                that._xfa().Logger.debug("xfa", "referred field with id " + embed + " doesn't exist.");
                                $span.remove();
                            }
                        }
                        else {
                            that._xfa().Logger.debug("xfa", "referred field with invalid id " + embed + " doesn't exist.");
                            $span.remove();
                        }
                    });

                    //isTextEmbeds is set to true if there is any embedded text field.
                    if (isTextEmbeds) {
                        content.jsonValue = "<span>" + $internalHTML.html() + "</span>";
                        // pages may not yet be rendered, but initialize called due to "initial count" of rpt. SF
                        // record updated value to be applied in _syncFormNodeToHtml during pg. render
                    }
                }
            }
        },

        scopeless: function () { //[LC-8801] DOM Properties of draw gets incorrectly attached
            return false;
        },

        _eventHandler: function (eventName) {
            //want to handle only calculate event that too in case of draw text
            if (this.ui && this.ui.oneOfChild && this.ui.oneOfChild.className == 'textEdit') {
                var rValue = undefined;
                switch (eventName) {
                    case "calculate":
                        if (this.moEvents["calculate"] && this.moEvents["calculate"].length > 0) {
                            this.moEvents["calculate"][0].execute(this, "calculate");
                        }
                        break;
                    default :
                        return Draw._super._eventHandler.call(this);
                }
                return rValue;
            }
            else
                return Draw._super._eventHandler.call(this);

        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap: function (map) {
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * @param map
         * @private
         */
        _restoreDataSomMap : function (map) {

        }
    });

    Draw.defineProps({
        "rawValue": {
            get: function () {
                return this._getValue();
            },
            set: function (sValue) {
                var oldval = this._getValue();
                sValue = this.validateInput(sValue, "string");
                this._setValue(sValue);
                var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this, 'rawValue', null, sValue);
                this.trigger(event.name, event);
            }
        },

        ui: {
            get: function () {
                return this.getElement("ui", 0);
            },

            set: function (value) {
                this.setElement(value, "ui");
            }
        },

        "font": {
            get: function () {
                return  this.getElement("font", 0);
            },
            set: function (value) {
                this.setElement(value, "font");
            }
        },

        "value": {
            get: function () {
                return  this.getElement("value", 0);
            },
            set: function (val) {
                this.setElement(val, "value");
            }
        },

        "desc": {
            get: function () {
                return this.getElement("desc", 0)
            }
        }
    });

    Draw.addMixins([
        xfalib.script.mixin.AddAssist,
        xfalib.script.mixin.AddCaption,
        xfalib.script.mixin.AddXYWH,
        xfalib.script.mixin.AddPresence,
        xfalib.script.mixin.AddBorder,
        xfalib.script.mixin.AddPara,
        xfalib.script.mixin.AddMargin
    ]);

})(_, xfalib, $);





/**
 * @package xfalib.script.DateTimeField
 * @import xfalib.script.Field
 * @fileOverview The file creates the Date Time Field Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new Date Time Field class
     *
     * @constructor
     * @param {string}
        *            name the name of the Field
     * @param {string}
        *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends com.adobe.xfa.scripting.Node
     */
    var DateTimeField = xfalib.script.DateTimeField = xfalib.script.Field.extend({
        _getDefaultPictureClause: function() {
            //watson bug#3672364 and 3672367.
            //Start reading calendar picture format from the localeset.
            if(this.value.oneOfChild.className === "date")
                return "date{"+this._xfa()._getLocaleSymbols(this.locale,"datePatterns").med+"}";
            else
                return "";
        },

        _setValue: function (sVal, skipTypeCheck) {
            return DateTimeField._super._setValue.call(this, sVal, skipTypeCheck);
        },

        _showDisplayFormat: function () {
            var formattedValue = this.formattedValue,
                rawValue = this.rawValue;
            // if formattedValue is null then show rawValue in widget along with error message
            if (!formattedValue) {
                formattedValue = rawValue;
            }
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'rawValue', rawValue, formattedValue);
            this.trigger(evnt.name, evnt);
        }
    });
})(_, xfalib);
/**
 * @package xfalib.script.NumericField
 * @import xfalib.script.Field
 * @fileOverview The file creates the Numeric Field Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new Numeric Field class
     *
     * @constructor
     * @param {string}
        *            name the name of the Field
     * @param {string}
        *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends com.adobe.xfa.scripting.Node
     */
    var NumericField = xfalib.script.NumericField = xfalib.script.Field.extend({
         _getDefaultPictureClause: function() {
            return "num{"+this._xfa()._getLocaleSymbols(this.locale,"numberPatterns").numeric+"}";
         }
    });
})(_, xfalib);
/**
 * @package xfalib.script.ButtonField
 * @import xfalib.script.Field
 * @fileOverview The file creates the Button Field Class required for XFA
 *               library
 * @version 0.0.1
 */

(function (_, xfalib) {
    var ButtonField = xfalib.script.ButtonField = xfalib.script.Field.extend({
        _computeJsonDiff: function (diff_level) {
            //we don't want button to appear in final submit, but for restoreFormState
            return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level === 2, ButtonField._super._computeJsonDiff, arguments);
        }
    });
})(_, xfalib);

/**
 * @package xfalib.script.CheckButtonField
 * @import xfalib.script.Field
 */
/**
 * @fileOverview The file creates the CheckButton Field Class required for XFA
 *               library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new CheckButtonField Field class
     *
     * @constructor
     * @param {string}
        *            name the name of the Field
     * @param {string}
        *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends com.adobe.xfa.scripting.Node
     */
    var CheckButtonField = xfalib.script.CheckButtonField = xfalib.script.Field.extend({
        initialize : function(){
            CheckButtonField._super.initialize.call(this);
            this._on = 0;
            this._off = 1;
            this._neutral = 2;
        },

        addItem : function(sDisplayVal, sSaveVal) {
            if (this.length == this._getMaxItems())
                return;
            CheckButtonField._super.addItem.call(this, sDisplayVal, sSaveVal);
        },

        _getMaxItems : function(){
            return this._allowNeutral() ? 3 : 2;
        },

        _allowNeutral : function(){
            return this.ui.oneOfChild.allowNeutral == 1 ? true : false;
        },

        _handleDependants : function() {
            CheckButtonField._super._handleDependants.call(this);
            if (this.parent._isExclusionGroup()) {
                this.parent._handleSelectChild(this);
            }
        }

    });
})(_, xfalib);
/**
 * @package xfalib.script.ChoiceListField
 * @import xfalib.script.Field
 */
/**
 * @fileOverview The file creates the ChoiceList Field Class required for XFA
 *               library
 * @version 0.0.1
 */


(function(_, xfalib, $){
    /**
     * Creates a new ChoiceList Field class
     *
     * @constructor
     * @param {string}
        *            name the name of the Field
     * @param {string}
        *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends com.adobe.xfa.scripting.Node
     */
    var ChoiceListField = xfalib.script.ChoiceListField = xfalib.script.Field.extend({

        initialize : function () {
            ChoiceListField._super.initialize.call(this);
            // to handle the scenario where bindRef items were not getting populated on adding new instance
            if (this.getElement("#bindItems") && xfalib.runtime.renderContext.data) {
                var prefillXmlDoc = xfalib.ut.XMLUtils.getXFARootFormElementFromXML($.parseXML(xfalib.runtime.renderContext.data));
                this._playItems(prefillXmlDoc, null);
            }
        },

        _convertValueToXml: function(val) {
           if(val == null || val.length == 0)
                return null
           var xml = "<"+this.name+">"
           _.each((val+"").split("\n"),function(value) {
               if(value && value.length > 0)
                    xml +="<value>"+value+"</value>"
            })
            xml += "</"+this.name+">"
            return xml
        },

        _getText: function(xml,sep,$) {
            var recText = function(obj,arr) {
                if(obj.children().length) {
                    obj.children().map(function(indx,child) {
                        recText($(child),arr);
                    })
                } else {
                    arr.push(obj.text());
                }
            };
            var arr = [];
            recText($($.parseXML(xml)),arr);
            return arr.join(sep);
        },

        _convertXmlToValue: function($xml) {
            if($xml == null)
                return null;
            return this._getText($xml,"\n",$);
        },

        _getValue : function() {
            var value = ChoiceListField._super._getValue.apply(this, this._multiSelect() ? ["text/xml"] : []);
            if(this._multiSelect())
                return this._convertXmlToValue(value);
            else
                return value
        },

        _setValue : function(sVal) {
            if(this._multiSelect())
                sVal = this._convertValueToXml(sVal);
            return ChoiceListField._super._setValue.apply(this,[sVal]);
        },

        getItemState : function(nIndex) {
            if (this._multiSelect() !== false) {
                var saveValue = this.getSaveItem(nIndex);
                if(saveValue!== null && saveValue!== undefined){
                    saveValue = ""+saveValue;
                    var valueArray = (this.rawValue + "").split("\n");
                    var currentValIndex = this.xfaUtil().dIndexOf(valueArray,saveValue);
                    return currentValIndex >= 0;
                } else
                    return null; // TODO: return null or false
            } else {
                return ChoiceListField._super.getItemState.call(this, nIndex);
            }

        },

        // returns array of indices corresponding to selected value
        _selectedLastIndices : function() {
            var itemSize = this.length,
                lastSelectedIndices = [];

            for (var i=0; i< itemSize; i++) {
                if (this.getItemState(i)) {
                    lastSelectedIndices.push(i);
                }
            }
            return lastSelectedIndices;
        },

        // returns display value corresponding to selected value
        _formatValue: function () {
            var lastSelectedIndices = this._selectedLastIndices();
            return lastSelectedIndices.map( function (selIndex) {
                return this.getDisplayItem(selIndex);
            }, this).join("\n");
        },

        _multiSelect : function(){
            return this.ui.oneOfChild.open == "multiSelect" ? true : false;
        },



        setItemState : function(nIndex, bVal) {
            if (this._multiSelect() !== false) {
                var saveValue = this.getSaveItem(nIndex);
                if(saveValue !== null && saveValue !== undefined) {
                    saveValue = ""+saveValue;
                    var valueArray = (this.rawValue + "").split("\n");
                    var currentValIndex = this.xfaUtil().dIndexOf(valueArray,saveValue); /*item value is typed so converting it to string for matching */
                    if(bVal && currentValIndex < 0) {
                        var saveItems = this._getSaveItems().children
                        var newValArray = _.reduce(saveItems,function(memo,item) {
                                if(this.xfaUtil().dIndexOf(valueArray,item.value) >= 0 || item.value == saveValue)
                                    memo.push(item.value);
                                return memo
                        },[],this)
                        valueArray = newValArray;
                    }
                    else if(!bVal && currentValIndex >=0)
                        valueArray.splice(currentValIndex, 1)
                    this.rawValue = valueArray.join("\n");
                }
            } else {
                ChoiceListField._super.setItemState.call(this, nIndex, bVal);
            }
        },

        _playDataXML: function (xmlDocument, contextNode, currentBindRef) {
            var xpath = this._getXpathFromBindRef(),
                value, nodeIter, node;
            if(xpath != null) {
                if(this._multiSelect()) {
                    // in case of multiselect the value is xml and hence needs special processing
                    nodeIter = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                    var node = nodeIter.iterateNext();
                    if(node != null) {
                        value = new XMLSerializer().serializeToString(node);
                        ChoiceListField._super._setValue.apply(this,[value]);
                        //todo: If we move processing of data xml before view
                        //generation then showDisplayFormat call will not be needed.
                        this._showDisplayFormat();
                    }
                } else {
                    ChoiceListField._super._playDataXML.apply(this, [xmlDocument, contextNode, currentBindRef]);
                }
            }
            this._playItems(xmlDocument, contextNode);
        },

        _playItems: function (xmlDocument, contextNode) {
            var bindItems = this.getElement("#bindItems[0]");
            if (bindItems != null) {
                var connection = bindItems.connection;
                if (connection == null || connection.length == 0) {
                    var ref = bindItems.ref;
                    if (ref != null && ref.length > 0) {
                        var xpath = this._convertRefToXPath(ref);
                        if (xpath != null) {
                            var itemNodes = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                            if (itemNodes != null) {
                                this.clearItems();
                                var itemNode = itemNodes.iterateNext();
                                var xmlUtils = xfalib.ut.XMLUtils;
                                while (itemNode != null) {
                                    //TODO: support valueRef/labelRef with xPath having more than one element
                                    // and valueRef/labelRef pointing to an attribute
                                    var valueNodeResult = xmlUtils.evaluateXPath(bindItems.valueRef, itemNode, null,
                                        XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                                    if (valueNodeResult != null) {
                                        var labelNodeResult = valueNodeResult;
                                        if (bindItems.labelRef) {
                                            labelNodeResult = xmlUtils.evaluateXPath(bindItems.labelRef, itemNode, null,
                                                XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                                        }
                                        var valueNode = valueNodeResult.iterateNext();
                                        if(valueNode != null) {
                                            var labelNode = labelNodeResult ? labelNodeResult.iterateNext() : null;
                                            if(labelNode == null) {
                                                labelNode = valueNode;
                                                this._xfa().Logger.warn("xfa",
                                                        "labelRef doesn't exist for [" + this.somExpression + ","
                                                        + bindItems.ref + "," + bindItems.labelRef + "]");
                                            }
                                            this.addItem(labelNode.textContent,
                                                valueNode.textContent);
                                        } else {
                                            this._xfa().Logger.error("xfa",
                                                    "valueRef doesn't exist for [" + this.somExpression + ","
                                                        + bindItems.ref + "," + bindItems.labelRef + "]");
                                        }
                                    } else {
                                        this._xfa().Logger.error("xfa", "valueRef points to an invalid xml element "
                                            + bindItems.valueRef);
                                    }

                                    itemNode = itemNodes.iterateNext();
                                }
                            }
                        }
                    }
                } else {
                    this._xfa().Logger.warn("xfa", "connection in bindItems is not supported in Formset");
                }
            }
        },

        _appendValueInXMLElement: function (element) {
            if(!this._multiSelect()) {
                ChoiceListField._super._appendValueInXMLElement.apply(this,[element]);
            } else {
                // need to remove the old choices before appending the new ones
                while (element.firstChild) {
                    element.removeChild(element.firstChild);
                }
                var xmlValue = this.value.oneOfChild.getValue("text/xml"),
                    xmlDoc, nodeIter, node, importedNode, addedChild;
                if(xmlValue != null && xmlValue != "") {
                    xmlDoc = $.parseXML(xmlValue);
                    nodeIter = xfalib.ut.XMLUtils.evaluateXPath("*", xmlDoc.documentElement, null,
                                                                    XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                    node = nodeIter.iterateNext();
                    while(node != null) {
                        importedNode = element.ownerDocument.importNode(node, false);
                        addedChild = element.appendChild(importedNode);
                        addedChild.textContent = node.textContent;
                        node = nodeIter.iterateNext();
                    }
                }
            }
        }
    });
})(_, xfalib, $);
/**
 * @package xfalib.script.Subform
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the Subform Class required for XFA library
 * @class The class represents a subform in the XFA Dom
 * @version 0.0.1
 */
(function(_,xfalib){
    var Subform = xfalib.script.Subform = xfalib.script.EventContainerNode.extend({
        initialize: function() {
            Subform._super.initialize.call(this);
            this._instanceManager = null;
            this.mnInstanceIndex = 0;
            this.tests= [this._scriptTest];
        },

        _isSubform : function() {
            return true;
        },

        getInvalidObjects : function() {
            var list = new xfalib.script.XfaList();
            var sMessages = new Array();
            this._validate(sMessages);
            for ( var i = 0; i < sMessages.length; i++) {
                list._append(sMessages[i].ref);
            }
            return list;
        },

        _eventHandler : function(eventName) {
            var rValue = undefined;
            switch (eventName) {
                case "validate":
                    if(this.moEvents["validate"] && this.moEvents["validate"].length >0){
                        rValue = this.moEvents["validate"][0].execute(this, "validate");
                    }else
                        rValue = true;
                    break;
                case "$formpreSubmit":
                    rValue = this._preSubmitEventHandler();
                default:
                if (this.moEvents[eventName]) {
                    for ( var i = 0; i < this.moEvents[eventName].length; i++) {
                        this.moEvents[eventName][i].execute(this, eventName);
                    }
                }
            }
            return rValue;
        },

        _nullTest : function(value,sMessages) {
            return true;
        },

        _requireGetterSetter : function(oChild){
            if(oChild.className == "pageSet")
                return true;
            else
                return Subform._super._requireGetterSetter.call(this, oChild);
        },

        _postAddChild : function(oNode){
            if(oNode.instanceManager){
                // clear all cached contexts in EventContainerNode-s
                xfalib.runtime.xfa._clearAllMoContexts();

                this._xfa()._xfaTemplateCache.putModel(oNode, oNode.instanceManager._instanceTemplate());
                if(this.mEffectiveAccess){
                    oNode._calculateEffectiveAccess();
                }
                if(this.mEffectivePresence){
                    oNode._calculateEffectivePresence();
                }
                oNode._initialize();
                if (this.mbInitialized) {
                    // oNode.execEvent("initialize");
                    oNode.execCalculate();
                }

                // internalDispatchEvent(CollectionEventKind.ADD, oNode, index);

                // if (this.hasEventListener("change"))
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.CHILD_ADDED,this,"child",null,oNode);
                this.trigger(evnt.name,evnt);
            }
            else {
                //do nothing --- Let's face it You might call this function for other things besides subform e.x. items (see _getDisplayItems())
                Subform._super._postAddChild.call(this, oNode);
            }
        },

        _postRemoveChild : function(oChild){
            if(oChild.instanceManager){
                // clear all cached contexts in EventContainerNode-s
                xfalib.runtime.xfa._clearAllMoContexts();

                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.CHILD_REMOVED,this,"child", oChild, null);
                this.trigger(evnt.name,evnt);
            }
            else {
                Subform._super._postRemoveChild.call(this, oChild);
            }
        },

        playJsonForElement : function(elName, pJsonModel){
            if(elName == "instanceManager"){
                var newJChildren = _.filter(_.compact(pJsonModel.children), function (jChild) {
                    return this.xfaUtil().isRepeatabeEl(jChild._class) || jChild._class == "instanceManager";
                }, this);
                var oldMChildren = _.filter(this.moChildNodes, function(mChild){
                    return  this.xfaUtil().isRepeatabeEl(mChild.className)  || mChild.className == "instanceManager" ;
                }, this);

                var lastIM = null;
                _.each(oldMChildren, function(oldMChild){
                    //If oldMChild has any remaining IM then newJChildren must have at least one IM left
                    if(oldMChild.className == "instanceManager" && newJChildren[0]._class == "instanceManager"){
                        newJChildren.shift();
                    }
                    else if(oldMChild.className == "instanceManager" && this.xfaUtil().isRepeatabeEl(newJChildren[0]._class)){
                        while(this.xfaUtil().isRepeatabeEl(newJChildren[0]._class)){
                            var addedSf =lastIM.addInstance();
                            addedSf.playJson(newJChildren.shift());
                        }
                        newJChildren.shift(); // This must be instanceManager for next subform
                    }
                    else if(this.xfaUtil().isRepeatabeEl(oldMChild.className ) && (newJChildren[0] == null || newJChildren[0]._class == "instanceManager")){
                        lastIM.removeInstance(oldMChild.instanceIndex);
                    }
                    else {
                        //oldMChild.className == "subform" && newJChildren[0]._class == "subform"
                        oldMChild.playJson(newJChildren.shift());
                    }

                    if(oldMChild.className == "instanceManager" )
                        lastIM = oldMChild;

                }, this);
                while(newJChildren.length > 0){
                    var newJSF = newJChildren.shift();
                    var addedSF = lastIM.addInstance();
                    if (addedSF) {
                        addedSF.playJson(newJSF);
                    }
                }
                return true;
            } else if (this.xfaUtil().isRepeatabeEl(elName)) {
                return true;
            } else if (elName === "variables") {
                return true;  // LC-9508: don't playJson for variables
            } else {
                return Subform._super.playJsonForElement.call(this, elName, pJsonModel);
            }
        },

        _getXPathForUseNameBinding: function () {
            if(this.instanceManager._isRepeatable()) {
                var name = this.getAttribute("name");
                return name === "" ? null
                                   : {
                                        relative: true,
                                        bindRef: name + "[*]"
                                     };
            } else {
                return Subform._super._getXPathForUseNameBinding.apply(this);
            }
        },

        _playDataXML: function(xmlDocument, contextNode, currentBindRef) {
            if(this.parent.className === "form") {
                return Subform._super._playDataXML.apply(this,[xmlDocument,contextNode, currentBindRef]);
            }
            var xpath = this._getXpathFromBindRef(),
                relativeXPath, nodeIter, nodeList = [], node, count, instance;
            if(xpath == null) {
               Subform._super._playDataXML.apply(this,[xmlDocument,contextNode, currentBindRef]);
            } else {
                // The first instance will take care of the rest of the instances.
                if(this.instanceIndex === 0) {
                    nodeIter = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                    if (nodeIter != null) {
                        node = nodeIter.iterateNext();
                        while (node) {
                            nodeList.push(node);
                            node = nodeIter.iterateNext();
                        }
                        node = nodeList.shift();
                        count = 0;
                        while (node != null) {
                            if (count > this.instanceManager.count - 1) {
                                instance = this.instanceManager.addInstance();
                            } else {
                                instance = this.instanceManager.instances[count];
                            }
                            Subform._super._playDataXML.apply(instance, [xmlDocument, node, xpath]);
                            node = nodeList.shift();
                            count++;
                        }
                        while (count < this.instanceManager.count) {
                            if (this.instanceManager.count === this.instanceManager.min) {
                                instance = this.instanceManager.instances[count];
                                Subform._super._playDataXML.apply(instance, [xmlDocument, null, xpath]);
                                count++;
                            } else {
                                this.instanceManager.removeInstance(count);
                            }
                        }
                    }
                }
            }
        },

        /**
         * Generates the XML by appending the elements in the rootNode
         * @param rootNode The rootNode of the xml. Generally the element that maps to the root of the form
         * @param contextNode Current Node where to insert the elements in case of relative bindings
         */
        generateDataXML: function(rootNode, contextNode) {
            if(this.parent.className === "form") {
                return Subform._super.generateDataXML.apply(this,[rootNode,contextNode]);
            }
            var xpath = this._getXpathFromBindRef(),
                xmlUtils = xfalib.ut.XMLUtils,
                parentElement, element, childElement, childXPath, childXPathParts,
                childElementName, childElementIndex;
            if(xpath == null) {
                Subform._super.generateDataXML.apply(this,[rootNode,contextNode]);
            } else {
                element = xpath.relative === false ? rootNode : contextNode;
                parentElement = xmlUtils.createElementsFromXPath(xpath.bindRef, element, true);
                childXPath = _.last(xpath.bindRef.split("/"));
                childXPathParts = xmlUtils._getElementNameAndIndexFromXPathPart(childXPath);
                childElementName = childXPathParts.name;
                childElementIndex = childXPathParts.index;
                //TODO: * doesn't gaurantees that the element can be repeated in schema. But we have no choice for now
                if(childElementIndex === "*") {
                    if(this.instanceIndex === 0) {
                        // For repeatable subforms the first child does the processing for all the siblings

                        // cache all existing children
                        var existingInstances = parentElement.hasChildNodes() ? parentElement.childNodes : null;

                        // filter out current repeatable ones
                        if (!_.isEmpty(existingInstances)) {
                            existingInstances = _.filter(existingInstances, function (child) { return child.nodeName === childElementName; });
                        }

                        _.each(this.instanceManager.instances, function (instance) {
                            var index = instance.instanceIndex + 1,
                                childElement = xmlUtils.findOrCreateElement(childElementName + "[" + index + "]",
                                    parentElement);
                            Subform._super.generateDataXML.apply(instance,[rootNode, childElement]);
                        }, this);

                        if(!_.isEmpty(existingInstances)) {
                            // remove the left over ones, caused if one deletes an instance.
                            // since we are regenerating xml, no need to worry about order, remaining SFs will update their data from the xml's top elems
                            for(var i = this.instanceManager.count; i < existingInstances.length; ++i) {
                                parentElement.removeChild(existingInstances[i]);
                            }
                        }
                        // But this will have a side effect in case of any other repeatable subform mapping to the same xpath LC-3911518
                    }
                } else {
                    childElement = xmlUtils.findOrCreateElement(childElementName +"[" + childElementIndex + "]",
                        parentElement);
                    Subform._super.generateDataXML.apply(this,[rootNode, childElement]);
                }
            }
        },

        _getDataSomMap : function (dataSomMap) {
            if(!this.instanceManager || !this.instanceManager._isRepeatable()) {
                return Subform._super._getDataSomMap.apply(this,arguments)
            }
            return dataSomMap;
        },

        _restoreDataSomMap: function(map) {
            if(!this.instanceManager || !this.instanceManager._isRepeatable()) {
                Subform._super._restoreDataSomMap.apply(this,arguments)
            }
        },

        _preSubmitEventHandler: xfalib.script.Field.prototype._preSubmitEventHandler
    });

    Subform.defineProps({
        "locale": {
            get: function() {
                var obj = this;
                var locale;
                while(!locale && obj) {
                    locale = obj.jsonModel.locale;
                    obj = obj.parent;
                }
                locale = locale || "en-US"; //TODO: read from jsp
                return locale;
            }
        },

        "instanceIndex":
        {
            get : function() {
                return this.mnInstanceIndex;
            }
        },

        "instanceManager": {
            get: function() {
                return this._instanceManager;
            },
            resolve:true
        },

        "occur": {
            get: function() {
                return this.instanceManager.occur;
            },
            resolve:true
        },

        "pageSet": {
            get: function(){
                return this.getElement("pageSet", 0, true);
            }
        },

        "variables": {
            get : function() {
                return  this.getElement("variables",0);
            } ,
            set :function(value) {
                this.setElement(value,"variables");
            }
        }
    });

    Subform.addMixins([
        xfalib.script.mixin.AddAssist,
        xfalib.script.mixin.AddPresence,
        xfalib.script.mixin.AddXYWH,
        xfalib.script.mixin.AddFillColor,
        xfalib.script.mixin.AddBorder,
        xfalib.script.mixin.AddBorderColor,
        xfalib.script.mixin.AddBorderWidth,
        xfalib.script.mixin.AddPara,
        xfalib.script.mixin.AddMargin
    ]);

})(_,xfalib);
/**
 * @package xfalib.script.ContentArea
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the ContentArea Class required for XFA library
 * @version 0.0.1
 */

(function (_, xfalib) {
    /**
     * Creates a new ContentArea class
     *
     * @class The class represents a subform in the XFA Dom
     * @param {string}
     *            name the name of the node
     * @extends com.adobe.xfa.scripting.ContainerNode
     */
    var ContentArea = xfalib.script.ContentArea = xfalib.script.ContainerNode.extend({
        _computeJsonDiff: function (diff_level) {
            return xfalib.ut.XfaUtil.prototype.partialStripOrCall.call(this, diff_level, ContentArea._super._computeJsonDiff);
        }
    });

    ContentArea.addMixins([
        xfalib.script.mixin.AddXYWH
    ]);

})(_, xfalib);

/**
 * @package xfalib.script.PageArea
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the PageArea Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new PageArea class
     *
     * @class The class represents a subform in the XFA Dom
     * @param {string}
        *            name the name of the node
     * @extends com.adobe.xfa.scripting.ContainerNode
     */
    var PageArea = xfalib.script.PageArea = xfalib.script.EventContainerNode.extend({
        execEvent : function(eventName) {
            return undefined;
        },

        playJsonForElement: xfalib.script.Subform.prototype.playJsonForElement,

        _computeJsonDiff: function (diff_level) {
            return xfalib.ut.XfaUtil.prototype.partialStripOrCall.call(this, diff_level, PageArea._super._computeJsonDiff);
        }
    });

    PageArea.defineProps({
        "access" : {
            get : function() {  //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            }
        },


        "presence" : {
            get : function() { //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.presence, this._defaults.presence);
            }
        }
    });
})(_, xfalib);




/**
 * @package xfalib.script.PageSet
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the PageSet Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new PageSet class
     *
     * @class The class represents a subform in the XFA Dom
     * @param {string}
        *            name the name of the node
     * @extends com.adobe.xfa.scripting.ContainerNode
     */
    var PageSet = xfalib.script.PageSet = xfalib.script.EventContainerNode.extend({
        execEvent : function(eventName) {
            return undefined;
        },

        _computeJsonDiff: function (diff_level) {
            return xfalib.ut.XfaUtil.prototype.partialStripOrCall.call(this, diff_level, PageSet._super._computeJsonDiff);
        },

        playJsonForElement: function (elName, pJsonModel) {
            if(elName === "pageArea") { // LC-3642518 : allow data-merge on master page
                var newJChildren = _.filter(_.compact(pJsonModel.children), function (jChild) {
                    return jChild._class === "pageArea";
                }, this);
                var oldMChildren = _.filter(this.moChildNodes, function (mChild) {
                    return mChild.className === "pageArea";
                }, this);

                _.each(oldMChildren, function (oldMChild) {
                    var idPattern = new RegExp("^" + oldMChild.jsonModel.id + "(?:_ID)*$"); // look for an id value, followed by zero or more "_ID" suffixes
                    _.each(newJChildren, function (newJChild) {
                        if (oldMChild.name && oldMChild.name == newJChild.name && idPattern.test(newJChild.id)) { // match name as well as id, to account for mystery xtg master pg id gen logic
                            try {
                                oldMChild.playJson(newJChild); // may throw an exception, say for 0-instance fields on master pg. Say expected an inst.man but found null
                            } catch (exception) {
                                xfalib.runtime.xfa.Logger.error("xfa", "Exception during DataMerge on fields in master page. ",
                                                                [exception, oldMChild," PlayJSON on", newJChild]);
                            }
                        }
                    }, this);
                }, this);

                return true;
            } else {
                return PageSet._super.playJsonForElement.call(this, elName, pJsonModel);
            }
        }
    });

    PageSet.defineProps({
        "access" : {
            get : function() {  //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            }
        },

        "presence" : {
            get : function() { //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.presence, this._defaults.presence);
            }
        }

    });
})(_, xfalib);
/**
 * @fileOverview The file creates the SubformSet Class required for XFA library
 * @class The class represents a SubformSet in the XFA Dom
 * @version 0.0.1
 */
(function(_,xfalib){
    var SubformSet = xfalib.script.SubformSet = xfalib.script.Subform.extend({
        initialize: function() {
            SubformSet._super.initialize.call(this);
            this.tests = null;
        },

        execEvent : function(eventName) {
            return undefined;
        }

    });

    SubformSet.defineProps({
        "access": {
            get: function () {  //i am not sure how to make this property undefined so just removed setters for now
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            }

            //TODO : Add setter to delegate to children

        },

        "presence": {
            get: function () { //i am not sure how to make this property undefined so just removed setters for now
                return this.getOrElse(this.jsonModel.presence, this._defaults.presence);
            }

            //TODO : Add setter to delegate to children
        }

    });
})(_,xfalib);/**
 * @fileOverview The file creates the Area Class required for XFA library
 * @class The class represents a Area in the XFA Dom
 * @version 0.0.1
 */
(function(_,xfalib){
    var Area = xfalib.script.Area = xfalib.script.EventContainerNode.extend({
        execEvent : function(eventName) {
            return undefined;
        },

        playJsonForElement : xfalib.script.Subform.prototype.playJsonForElement

    });

    Area.defineProps({
        "access" : {
            get : function() {  //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            }
        },

        "presence" : {
            get : function() { //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.presence, this._defaults.presence);
            }
        }

    });

    Area.addMixins([
        xfalib.script.mixin.AddXYWH
    ]);

})(_,xfalib);/**
 * @fileOverview The file creates the Variables Class required for XFA library
 * @class The class represents a Variables in the XFA Dom
 * @version 0.0.1
 */
(function (_, xfalib) {
    var Variables = xfalib.script.Variables = xfalib.script.ContainerNode.extend({
        _initChildren: function () {
            var children = new Array();
            if (this.jsonModel.children) {
                var j = 0;
                for (var i = 0; i < this.jsonModel.children.length; i++) {
                    var child = this.jsonModel.children[i];
                    var childModel = xfalib.script.XfaModelRegistry.prototype.createNodeValue(child);
                    if (childModel) {
                        children[j++] = childModel;
                    }
                }
                this.children = children;
            }
        },

        _computeJsonDiff: function (diff_level) {
            // don't need variables for submission, but need them for replay on restoreFormState
            return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level === 2, Variables._super._computeJsonDiff, arguments);
        },

        scopeless: function () {
            return ((this.name || "").length == 0);
        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap: function (map) {
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * @param map
         * @private
         */
        _restoreDataSomMap : function (map) {

        }

    });

    Variables.defineProps({
        "presence": {
            get: function () { //i am not sure how to make this property undefined so just removed setters
                return undefined;
            },
            set: function () {
            }
        }

    });
})(_, xfalib);
/**
 * @package xfalib.script.Occur
 * @import xfalib.ut.Class
 * @fileOverview The file creates the Occur Class required by InstanceManager
 *               for XFA library
 * @version 0.0.1
 */


(function(_, xfalib){
    /**
     * Creates a new Occur object
     *
     * @class The class represents the Occur Object
     * @constructor
     * @param {number}
        *            initial Initial occurrence of the subform managed by parent
     *            InstanceManager
     * @param {number}
        *            max Maximum occurrence of the subform managed by parent
     *            InstanceManager
     * @param {number}
        *            min Minimum occurrence of the subform managed by parent
     *            InstanceManager
     * @property {number} initial Initial occurrence of the subform managed by
     *           parent InstanceManager
     * @property {number} max Maximum occurrence of the subform managed by parent
     *           InstanceManager
     * @property {number} min Minimum occurrence of the subform managed by parent
     *           InstanceManager
     */
    var Occur = xfalib.script.Occur = xfalib.ut.Class.extend({
        _defaults : {
            "min" : "1",
            "max" : "1",
            "initial" : "1"
        },
        msClassName: "occur"

    });

    Occur.defineProps({
        initial:{
            get: function() {
                return parseInt(this.getOrElse(this.jsonModel.initial, this._defaults.initial));
            }
        },

        min: {
            get: function() {
                return parseInt(this.getOrElse(this.jsonModel.min, this._defaults.min));
            },
            set: function(nMin) {
            	this.jsonModel.min = nMin + "";
            }
        },

        max: {
            get: function() {
                return parseInt(this.getOrElse(this.jsonModel.max, this.min));
            },
            set: function(nMax) {
            	this.jsonModel.max = nMax + "";
            }
        },

        playJson : function(pJsonModel) {

        }

    })
})(_, xfalib);
/**
 * @package xfalib.script.InstanceManager
 * @import xfalib.script.Node
 * @import xfalib.script.Occur
 * @fileOverview The file creates the InstanceManager Class required for XFA
 *               library
 * @class The class represents a Instance Manager to manage multiple instance of
 *        subforms
 * @version 0.0.1
 */

(function (_, xfalib) {

    var InstanceManager = xfalib.script.InstanceManager = xfalib.script.Node.extend(
        {
            msClassName: "instanceManager",
            initialize: function () {
                InstanceManager._super.initialize.call(this);
                this._occur = new xfalib.script.Occur({"jsonModel": this.jsonModel});
                this.moChildrenCreated = [];
                this.mnCurrent = 0;
                this.mbStandalone = false;
            },

            _instanceTemplate: function () {
                var parent = this.parent;
                if (this._templateRef() == null || parent == null || parent._templateRef() == null || parent._templateRef().children == null)
                    return null;
                var tmpltParent = parent._templateRef();
                var imIndex = tmpltParent.children.indexOf(this._templateRef());
                if (imIndex < 0 || tmpltParent.children.length < imIndex + 2)
                    return null;
                else {
                    return tmpltParent.children[imIndex + 1];
                }
            },

            _isRepeatable: function () {
                var max;
                return ((max = +this.max) < 0 || +this.min < max);
            },

            _isInstanceManager: function () {
                return true;
            },

            /**
             * @private
             *
             * Manage a child instance that was created.
             *
             * @param oCreatedChild
             *        the child to be managed.
             */


            _manageChild: function (oCreatedChild, nIndex) {
                oCreatedChild._instanceManager = this;
                if (this.moChildrenCreated.length >= 1) {
                    oCreatedChild = this._updateDataSomForRepeatedRows(oCreatedChild);
                }
                if (nIndex === undefined) {
                    this.moChildrenCreated.splice(this.mnCurrent, 0, oCreatedChild);
                    oCreatedChild.mnInstanceIndex = this.mnCurrent++;
                }
                else {
                    this.moChildrenCreated.splice(nIndex, 0, oCreatedChild);
                    oCreatedChild.mnInstanceIndex = nIndex;
                    this.mnCurrent++;
                    for (var i = nIndex + 1; i < this.moChildrenCreated.length; i++)
                        this.moChildrenCreated[i].mnInstanceIndex = i;
                }
            },

            _replaceLastOccurrenceOfSubString: function(string, find, replace) {
                var lastIndex = string.lastIndexOf(find);
                if (lastIndex === -1) {
                    return string;
                }
                var beginString = string.substring(0, lastIndex);
                var endString = string.substring(lastIndex + find.length);
                return beginString + replace + endString;
            },

            _updateDataSomForRepeatedRows: function(oCreatedChild) {
                var currentDataSom = oCreatedChild.jsonModel.extras.dataSom;
                var lengthOfChildCreated = this.moChildrenCreated.length;
                var lastAddedRowDataSom = this.moChildrenCreated[lengthOfChildCreated - 1].jsonModel.extras.dataSom;
                if (currentDataSom && lastAddedRowDataSom) {
                    var indexToUpdate = currentDataSom.substring(currentDataSom.lastIndexOf("[") + 1, currentDataSom.lastIndexOf("]"));
                    var updatedDataSomIndex = lastAddedRowDataSom.substring(lastAddedRowDataSom.lastIndexOf("[") + 1, lastAddedRowDataSom.lastIndexOf("]"));
                    updatedDataSomIndex++;
                    var updatedDataSom = this._replaceLastOccurrenceOfSubString(currentDataSom, indexToUpdate, updatedDataSomIndex);
                    oCreatedChild.jsonModel.extras.dataSom = updatedDataSom;
                    oCreatedChild.resolveNode("#extras.FS_EXTRAS.FS_DATA_SOM").value = updatedDataSom;
                }
                return oCreatedChild;
            },

            _computeJsonDiff: function (diff_level) {
                //we don't need InstanceManager for final submission if there is only one instance, and it's not a repeatable SF
                // but need it for maintaining hierarchy in restoreFormState
                return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level === 2 && (!this._isRepeatable() && this.moChildrenCreated.length <= 1), InstanceManager._super._computeJsonDiff, arguments);
            },

            /*
             * add an instance of the repeatable subform.
             */
            addInstance: function () {
                return this._insertInstance();
            },

            _insertInstance: function (nIndex, oChildAdded) {
                if ((+this.max >= 0) && (+this.max == this.count)) //TODO : discuss whether to use private variables or not
                    return null;
                if (nIndex !== undefined && nIndex > +this.count)
                    return null;

                if (oChildAdded === undefined) {
                    var sfTemplate = this._instanceTemplate();
                    //
                    // needs to add an instance to the model
                    //
                    if (sfTemplate == null)
                        return null;
                    var clonedJson = {};
                    var uniquePrefix = this.xfaUtil().generateUID();
                    this.copyObject(sfTemplate, clonedJson,
                        {
                            exceptions: ["htmlId"],
                            transformMaps: {
                                "dataId": function (srcValue, options) {
                                    return uniquePrefix + "_" + srcValue;
                                }
                            }
                        }
                    );
                    oChildAdded = xfalib.script.XfaModelRegistry.prototype.createModel(clonedJson);
                }
                if (oChildAdded != null) {
                    //
                    // first add the child to the list of managed children
                    //
                    oChildAdded._newChild = true
                    this._manageChild(oChildAdded, nIndex);
                    //
                    //TODO: If not standalone mode, add the new item to the parent container as well. Understanding standalone mode
                    //
                    if (this.mbStandalone == true) {
                        if (nIndex !== undefined)
                            oChildAdded.index = nIndex;
                        else
                            oChildAdded.index = this.mnCurrent;
                        oChildAdded.parent = this.parent;
                    } else {
                        var oParentContainer = this.parent;
                        if (oParentContainer != null) {
                            if (this.mnCurrent > 1 && nIndex!==0) {
                                //
                                // If we already had children get the index of first
                                // child in the parent container
                                //
                                nIndex = nIndex !== undefined ? nIndex : this.mnCurrent - 1;
                                var nInsertionIndex = oParentContainer
                                    ._getChildIndex(this.moChildrenCreated[nIndex - 1]);
                                nInsertionIndex++;
                                oParentContainer._addChildAt(oChildAdded,
                                    nInsertionIndex);
                            } else {
                                //
                                // If this is the first child, add it just after the
                                // instance manager
                                //
                                oParentContainer._addChildAt(oChildAdded,
                                        oParentContainer._getChildIndex(this) + 1);
                            }

                        }
                    }
                    if (_.contains(['INITIALIZED', 'INITIALIZING'], this._xfa()._modelInitialize)) {
                        try {
                            oChildAdded.execInitialize();
                            // if the instance being added is the first one, we need to run execCalculate on the form to get dependents
                            // for the instance being added.
                            if (this.count == 1) {
                                this._xfa().form.execCalculate();
                            } else {
                                var firstInstance = this.instances[0];
                                this._triggerCalculateForDependantFields(firstInstance);
                                oChildAdded.execCalculate();
                            }
                        } catch (ex) {
                            this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-013"], ["addInstance"]);
                        }
                    }
                    return oChildAdded;
                }
                return null;
            },

            insertInstance: function (nIndex) {
                return this._insertInstance(nIndex);
            },


            moveInstance: function (sIndex, dIndex) {
                if ((+this.max >= 0) && dIndex >= +this.count || sIndex >= +this.count || sIndex == dIndex) //TODO : discuss whether to use private variables or not
                    return null;
                var tIndex,
                    oParentContainer = this.parent,
                    oChild = this.moChildrenCreated[sIndex],
                    tsIndex = dIndex < sIndex ? sIndex + 1 : sIndex,
                    tdIndex = dIndex > sIndex ? dIndex + 1 : dIndex;
                this.max++;
                var newChild = this._insertInstance(tdIndex);
                this.max--;
                newChild.playJson(oChild.jsonModel);
                if (oParentContainer != null) {
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.CHILD_MOVED, oParentContainer, "child", null, null);
                    oParentContainer.trigger(evnt.name, evnt);
                }
                this.removeInstance(tsIndex);
            },


            /*
             * add an instance of the repeatable subform.
             */
            removeInstance: function (index) {
                //
                // don't remove any more than the minimum
                //
                if (this.count == 0 || this.min == this.count)
                    return;

                if (index >= +this.count)
                    return;
                //
                // needs to remove an instance to the model
                //
                var firstInstance = this.instances[0];
                var oChild = this.moChildrenCreated[index];
                this.moChildrenCreated.splice(index, 1);
                this.mnCurrent--;
                for (var i = index; i < this.moChildrenCreated.length; i++)
                    this.moChildrenCreated[i].mnInstanceIndex = i;
                var parent = oChild.parent;
                parent._removeChild(oChild);

                if (_.contains(['INITIALIZED', 'INITIALIZING'], this._xfa()._modelInitialize)) {
                    try {
                        this._triggerCalculateForDependantFields(firstInstance);
                    } catch (ex) {
                        this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-013"], ["removeInstance"]);
                    }
                }
            },

            /*
             * empty function since there is no data associated with IM
             */
            resetData: function () {

            },

            setInstances: function (num) {
                this.count = num;
            },
            /*
             *
             */
            getNaked: function (nIndex, createGetterSetter, Obj, scope) {
                if (this.getAttribute("name").length > 0 && this.getAttribute("name") != "_")
                    InstanceManager._super.getNaked.apply(this, arguments);
            },

            playJson: function (pJsonModel) {

            },
            /*
             * Trigger calculate event for only the dependent fields in the repeatable subform
             */
            _triggerCalculateForDependantFields : function (model) {
                var modelChildren = model.moChildNodes;
                _.each(modelChildren, function(modelChild){
                    // trigger calculate for the dependents of the field and exclusion group
                    if (modelChild._isField() || modelChild._isExclusionGroup()) {
                        var dependantNodes = modelChild.dependant;
                        _.each(dependantNodes, function(dependantNode){
                            dependantNode.execEvent("calculate");
                        });
                    } else if (modelChild._isEventNode()) {
                        this._triggerCalculateForDependantFields(modelChild);
                    }
                },this);
            }
        }
    );
    InstanceManager.defineProps({
        "min": {
            get: function () {
                return this.occur.min + "";
            },
            set: function (nMin) {
                this.occur.min = nMin;
            }
        },
        "max": {
            get: function () {
                return this.occur.max + "";
            },
            set: function (nMax) {
                this.occur.max = nMax;
            }
        },

        "occur": {
            get: function () {
                return this._occur;
            }
        },
        // This API is used in adaptive form
        "instances": {
            get: function() {
                return _.extend([], this.moChildrenCreated);
            }
        },

        "count": {
            get: function () {
                return this.moChildrenCreated.length + "";
            },
            set: function (value) {
                if (value == parseInt(value))
                    value = parseInt(value);
                else return;
                var count = +this.count,
                    tvalue = Math.abs(value - count),
                    max = +this.max,
                    min = +this.min;
                //Bug#3544368 value > max condition will only hold if max is positive (if max == -1
                // there is no limit on the upper count )
                if ((max > 0 && value > max) || value < min || value == count)
                    return;
                if (value > count) {
                    for (var i = 0; i < tvalue; i++)
                        this._insertInstance();
                }
                if (value < count) {
                    for (var i = 0; i < tvalue; i++)
                        this.removeInstance(--count);
                }
            }
        }
    })
})(_, xfalib);

/**
 * @package xfalib.script.ExclusionGroup
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the ExclusionGroup Class required for XFA
 *               library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new ExclusionGroup class
     *
     * @class The class represents a ExclusionGroup in the XFA Dom
     * @param {string}
        *            name the name of the node
     * @extends com.adobe.xfa.scripting.ContainerNode
     */
    var ExclusionGroup = xfalib.script.ExclusionGroup = xfalib.script.EventContainerNode.extend({

        initialize : function(){
            ExclusionGroup._super.initialize.call(this);
            this.tests= [this._nullTest,this._scriptTest];
            var dataId = this.getOrElse(this, "jsonModel.extras.dataId", null);
            if (dataId) {
                this._xfa().createDataNode(dataId, this);
            }
        },

        _getOnChild: function(otherChild) {
            return _.find(this.moChildNodes, function(child) {
                 return child.className == "field" && child.selectedIndex == 0 && child != otherChild
            })
        },

        _eventHandler : function(eventName) {
            var rValue = undefined;
            switch(eventName) {
                case "calculate":
                    if(this.moEvents["calculate"] && this.moEvents["calculate"].length >0){
                        rValue = this.moEvents["calculate"][0].execute(this, "calculate");
                    }
                    break;
                case "validate":
                    if(this.moEvents["validate"] && this.moEvents["validate"].length >0){
                        rValue = this.moEvents["validate"][0].execute(this, "validate");
                    }else
                        rValue = true;
                    break;
                case "$formpreSubmit":
                    rValue = this._preSubmitEventHandler();
                    break;
                default:
                    if (this.moEvents[eventName]) {
                        for ( var i = 0; i < this.moEvents[eventName].length; i++) {
                            this.moEvents[eventName][i].execute(this, eventName);
                        }
                    }
//                    ExclusionGroup._super._eventHandler.call(this, eventName);  //TODO: Why this is required?
            }
            return rValue
        },

        _handleSelectChild : function(child) {
            var oldVal = this.rawValue,
                evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                                                                this,"ClearError",null, null),
                onChild = this._getOnChild(child);

            this.trigger(evnt.name,evnt);

            if (child.selectedIndex == 0) {
                if(onChild)
                    onChild.setItemState(0,false);
                this._handleDependants();
                // trigger model change event for rawValue, so that value can be propogated to rest of the fields with same dataId
                var evntRawValue = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                                                                    this,"rawValue",this.rawValue, this.rawValue);
                this.trigger(evntRawValue.name,evntRawValue);
            } else if (child._matches(onChild)) {
                 this._handleDependants();
            }
        },

        selectedMember : function() {
            var currentNode = this._xfa().moCalculateEventNode;
            if (currentNode != null) {
                this.addDependant(currentNode);
            }
            return this._getOnChild();
        },

        _isExclusionGroup : function() {
            return true;
        },

        _getValue : function() {
            var onChild = this._getOnChild()
            return onChild ? onChild._getValue() : null;
        },

        _nullTest : function(sMessages) {
            var valid = true;
            var value = this._getValue();
            if (value == null && this.mandatory != "disabled") {
                this._mFailedValTest = "nullTest";
                this._mFailedValLevel = this.mandatory;
                this._errorText = this.mandatoryMessage;
                this._addMessage(sMessages, this._errorText, this._mFailedValLevel);
                valid = false;
            }
            return valid;
        },

        _getElementsFromXpath: xfalib.script.Field.prototype._getElementsFromXpath,

        _preSubmitEventHandler: xfalib.script.Field.prototype._preSubmitEventHandler,

        /**
         * Exclusion Group can have two types of prefill xml. Long format and short format . In case of Long format,
         * the value of each of  the children of exclusion group is present and hence we need to iterate the children to
         * prefill the value. For short format the textContent is the value of the Exclusion Group
         *
         * The difference between the short and Long format is that in short Format, there are no children of Exclusion
         * Group in xml.
         * @param xmlDocument
         * @param contextNode
         * @param currentBindRef
         * @private
         */
        _playDataXML: function(xmlDocument, contextNode, currentBindRef) {
            var xpath = this._getXpathFromBindRef(),
                nodeIter;
            if(xpath != null) {
                nodeIter = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                if(nodeIter != null) {
                    var node = nodeIter.iterateNext();
                    if(node != null) {
                        // node has further element childs then iterate over them otherwise set the content as its rawValue
                        if(node.childElementCount > 0) {
                            ExclusionGroup._super._playDataXML.apply(this, [xmlDocument, node, currentBindRef]);
                        } else {
                            this.rawValue = node.textContent;
                        }
                    }
                } else {
                    this._resetData();
                }
            }
        },

        generateDataXML: xfalib.script.Field.prototype.generateDataXML,

        _appendValueInXMLElement: xfalib.script.Field.prototype._appendValueInXMLElement
    });

    ExclusionGroup.defineProps({
        "rawValue" : {
            get : function() {
                var currentNode = this._xfa().moCalculateEventNode;
                if (currentNode != null) {
                    this.addDependant(currentNode);
                    // The children should not register the
                    // calculateNode as dependent on them, else the
                    // calculate event for calculateNode will be called
                    // multiple times.
                    this._xfa()._popCalculateEventNode();
                }

                var val = this._getValue();

                if (currentNode != null)
                    this._xfa()._pushCalculateEventNode(currentNode);

                return val;
            },
            set : function(oValue) {
            	var sMessages = new Array(),
                    onChild = this._getOnChild(),
                    oldVal = onChild ? onChild._getValue() : null

                oValue = this.validateInput(oValue, "string");
                if (oldVal === oValue)
                    return;
                if (onChild) {
                    onChild.setItemState(0, false);
                }
                onChild = _.find(this.moChildNodes, function(child) {
                                    return child.className == "field" &&
                                           child.getOrElse(child.getSaveItem(0), child.getDisplayItem(0)) == oValue
                                })
                if (onChild)
                    onChild.rawValue = oValue;
                this._handleDependants();
                this._xfa().queueValidateEvent(this);
            }
        },

        "mandatory" : {
            get : function() {
                return this.getOrElse(this.validate.nullTest, this._defaults.validate.nullTest);
            },
            set: function (value) {
                if(this.validate){
                    this.validate.nullTest = value;
                }
            }
        },

        "members" : {
            get : function() {
                var list = new xfalib.script.XfaList();
                this.moChildNodes.filter(function(elem) {
                    return elem._isField();
                }).map(function(elem1){
                    list._append(elem1);
                });
                return list;
            }
        },

        "isNull":{
            get : function() {
               if(this._getValue() != null)return false;
               else return true;
            }
        },

        "mandatoryMessage" : {
            get : function() {
                return xfalib.ut.XfaUtil.prototype._getMandatoryMessage(this);
            },
            set: function (val) {
                var nodes = this.validate.message.nodes;
                if (nodes.namedItem("nullTest") === null) {
                    var node = this._xfa().form.createNode("text", "nullTest");
                    nodes.append(node);
                }
                this.validate.message.nullTest.value = val;
                this.execValidate();
            }
        }
    });

    ExclusionGroup.addMixins([
        xfalib.script.mixin.AddAssist,
        xfalib.script.mixin.AddCaption,
        xfalib.script.mixin.AddPresence,
        xfalib.script.mixin.AddXYWH,
        xfalib.script.mixin.AddFillColor,
        xfalib.script.mixin.AddBorder,
        xfalib.script.mixin.AddBorderColor,
        xfalib.script.mixin.AddPara,
        xfalib.script.mixin.AddMargin
    ]);

})(_, xfalib);
/**
 * @package xfalib.script.Model
 * @import xfalib.script.Node
 */

(function(_, xfalib){
    var Model = xfalib.script.Model = xfalib.script.Element.extend({
        msClassName: "model",

        createNode : function(sClassName,sName,sNamespace) {    //TODO: looks incomplete
            sName = (typeof sName != 'undefined')?sName:"";
            sNamespace = (typeof sNamespace != 'undefined')?sNamespace:"";
            var jsonModel = {};
            jsonModel._class = sClassName;
            jsonModel.name = sName;
            var node = xfalib.script.XfaModelRegistry.prototype.createModel(jsonModel);
            return node;
        }
    });
})(_, xfalib);

/**
 * @package xfalib.script.Form
 * @import xfalib.script.ContainerNode
 */

(function (_, xfalib) {
    /**
     * @class
     * <p>
     * The Form class is the implementation of the top level XFA form object.
     * </p>
     *
     * <p>
     * The form object is accessed from the xfa object as xfa.form
     * </p>
     *
     */
    var Form = xfalib.script.Form = xfalib.script.EventContainerNode.extend({
        _getRootSubform: function () {
            return this.children[0];
        },

        _initialize: function () {
            this._xfa()._modelInitialize = 'INITIALIZING';
            var rootSubform = this._getRootSubform();
            rootSubform._initialize();
            //
            // Call all initialization then
            // calculations
            // scripts to execute
            //
            var pgSets = rootSubform.resolveNodes("#pageSet[*]");
            function execOnPgSets (execFuncname) {
                for(var i=0; i < pgSets.length; ++i) {
                    pgSets.item(i)[execFuncname]();
                }
            }

            rootSubform.execFormReady();
            execOnPgSets("execFormReady");
            rootSubform.execInitialize();
            execOnPgSets("execInitialize");
            rootSubform.execLayoutReady();
            execOnPgSets("execLayoutReady");
            rootSubform.execCalculate();
            this._xfa()._modelInitialize = 'INITIALIZED';
        },

        playJson: function (pJsonModel) {
            this._getRootSubform().playJson(pJsonModel.children[0]);
        },

        /**
         * @private
         * @function indicate that this is a Form node (~~).
         */
        _isForm: function () {
            return true;
        },

        execCalculate: function () {
            return this._getRootSubform().execCalculate();
        },

        execInitialize: function () {
            this._getRootSubform().execInitialize();
        },

        execFormReady: function () {
            this._getRootSubform().execFormReady();
        },

        execLayoutReady: function () {
            this._getRootSubform().execLayoutReady();
        },

        execValidate: function () {
            return this._getRootSubform().execValidate();
        },

        execPreSubmit: function () {
            return this._getRootSubform().execPreSubmit();
        },
        /**
         * remerge the data with the form model
         */
        remerge: function () {
            this._getRootSubform()._bind();
        },

        /**
         * recalculate this form model
         */
        recalculate: function (bool) {
            var xf = this._xfa();
            if (xf.host.calculationsEnabled) {
                if (xf.calculateRunning)
                    return;
                if (bool) {
                    this.execCalculate();
                    this.execFormReady();
                } else {
                    xf.runCalcs()
                }
            }
        },

        _computeJsonDiff: function (diff_level) {
            var diff = Form._super._computeJsonDiff.call(this, diff_level);
            diff.jsonDifference["versionNS"] = this.jsonModel["versionNS"];
            return { "changed": true,
                "jsonDifference": diff.jsonDifference
            };
        },

        createNode: xfalib.script.Model.prototype.createNode

    });
})(_, xfalib);
/**
 * @package xfalib.script.Host
 * @import xfalib.script.Node
 * @fileOverview The file creates the Host Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib, $){
    /**
     * @class The class represents the Host Object
     * @extends com.adobe.xfa.scripting.Node
     * @property {string} appType the application type of the host
     * @property {number} currentPage Page number of the form that is being
     *           displayed
     * @property {number} numPages total number of pages in the form
     * @property {name} name name of the application
     * @property {number} platform OS platform on which the application is running
     * @property {number} title title of the document
     * @property {number} version version number of the current application
     */
    var Host = xfalib.script.Host = xfalib.script.Node.extend({
        msClassName: "hostPseudoModel",
        initialize : function(){
            Host._super.initialize.call(this);
            this.jsonModel.name = "";
            this.mPageNumber = 0;
            this.pagingManager = null ;
            this.mCalculationsEnabled = true;
            this.mValidataionsEnabled = true;
            this.mNumPages = "";
            this.dataBrowser = [
                {
                    string: navigator.userAgent,
                    subString: "Chrome",
                    identity: "Chrome"
                },
                {
                    string: navigator.vendor,
                    subString: "Apple",
                    identity: "Safari",
                    versionSearch: "Version"
                },
                {
                    prop: window.opera,
                    identity: "Opera",
                    versionSearch: "Version"
                },
                {
                    string: navigator.userAgent,
                    subString: "Firefox",
                    identity: "Firefox"
                },
                {		// for newer Netscapes (6+)
                    string: navigator.userAgent,
                    subString: "Netscape",
                    identity: "Netscape"
                },
                {
                    string: navigator.userAgent,
                    subString: "MSIE",
                    identity: "Internet Explorer",
                    versionSearch: "MSIE"
                },
                {
                    string: navigator.userAgent,
                    subString: "Gecko",
                    identity: "Mozilla",
                    versionSearch: "rv"
                },
                { 		// for older Netscapes (4-)
                    string: navigator.userAgent,
                    subString: "Mozilla",
                    identity: "Netscape",
                    versionSearch: "Mozilla"
                }
            ];
        },

        _searchVersion : function(data,srch) {
            var index = data.indexOf(srch);
            if (index == -1) return;
            var spcIndex = data.indexOf(" ",index);
            if(spcIndex == -1)
                return data.substring(index+srch.length+1);
            return data.substring(index+srch.length+1,spcIndex);
        },

        _browserDetect : function() {
            var data = this.dataBrowser;
            for (var i=0;i<data.length;i++)	{
                var dataString = data[i].string;
                var dataProp = data[i].prop;
                var versionSearchString = data[i].versionSearch || data[i].identity;
                var version = this._searchVersion(navigator.userAgent,versionSearchString) || this._searchVersion(navigator.appVersion,versionSearchString) || "an unknown version";
                if (dataString) {
                    if (dataString.indexOf(data[i].subString) != -1)
                        return data[i].identity+" "+version;
                }
                else if (dataProp)
                    return data[i].identity+" "+version;
            }
        },

        /**
         * The function displays a dialog box on the screen. <br />
         * <b>TO DO</b><br />
         * <ul>
         * <li> The function doesn't supports icons as of now. Needs adding support for
         * that.</li>
         * <li> The dialog uses the default styling (provided by google). Need to change
         * that too. </li>
         * </ul>
         *
         * @function
         * @param {string}
            *            message The message to display
         * @param {string}
            *            title The title to appear in the dialog's window title
         * @param {number}
            *            type The icon to display: '0' (Error (default)), '1' (Warning),
         *            '2' (Question), and '3' (Status).
         * @param {number}
            *            buttons The buttons to display: '0' (OK (default)), '1' (OK,
         *            Cancel), '2' (Yes, No), and '3' (Yes, No, Cancel).
         */
        messageBox : function(message, title, type, buttons) {
            return (this._messageBox(message,title,type,buttons,null));
        },

        _messageBox : function(message, title, type, buttons,callback) {
            title = title || "";
            buttons = buttons || 0;
            var img =["Error","Warning","Question","Status"];
            var imgType = "";
            if(type!=undefined)
                imgType =  "[ " + img[type] + " ]  ";
            message = imgType  +  title + "\n\r" + message ;

            switch (buttons) {
                case 0:
                    alert(message);
                    return 1 ;
                case 1:
                    var a = confirm(message);
                    if(a==true)
                        return 1;
                    else return 2;
                case 2:
                    var a = confirm(message);
                    this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-009"]) ;
                    if(a==true)
                        return 4;
                    else return 3;

                case 3:
                    this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-010"]);
                    return 0;
            }
        },

        /**
         * The function displays the next page of the document (if one exists)
         *
         * @function
         */
        pageDown : function() {
            if (this.currentPage != this.numPages -1 ) {
                if(this.pagingManager)
                    this.pagingManager.pageDown();
            }
        },

        /**
         * The function displays the previous page of the document (if one exists)
         *
         * @function
         */
        pageUp : function() {
            if (this.currentPage != 0)  {
                var prevPage = this.currentPage - 1;
                var a = $($(".page")[prevPage])  ;
                window.scrollTo(0,a.offset().top) ;
            }
        },

        gotoURL: function(url, bNewFrame) {
            /*if(!$("a#gotourl").length)
                $("<a id='gotourl'></a>").appendTo('body');
            $("a#gotourl").attr("href",url)[0].click();
            //$("a").click();     */
            if(url.search("http") == -1)
                url = "http://" + url ;
            if(bNewFrame != true) {
                window.open(url) ;
            }
            else
                window.location = url;
        },

        resetData : function() {
            if(arguments.length)
                _.each(arguments,function(som) {
                    var node = this._xfa().resolveNode(som);
                    if(node)
                        node._resetData();
                },this)
            else {
                this._xfa().form._resetData();
            }
        },

        setFocus : function(som) {
            if(navigator.userAgent.match(/iPad/i) != null && this._xfa().moContextScriptEvent == 'change') {
            // LC-4663 : setFocus was shifting focus, before keypress was visible in browser.
            // Currently iPad doesnt support calling focus() from within setTimeout, so disabling the functionality.
                this._setFocus(som); // don't queue focus events, fire it immediately
            } else {
                this._xfa().queueFocusEvent(this, som);
            }
        },

         _setFocus : function(som) {
                    var node = som;
                    if(typeof som == "string")
                        node = this._xfa().resolveNode(som);
                    if(node != null){
                       if(this.pagingManager){
                            if(navigator.userAgent.match(/iPad/i) != null && this._xfa().moContextScriptEvent == 'change') {
                                this.pagingManager._makePageForHtmlId(node.htmlId); // LC-4663 : just render, not setFocus
                            } else {
                                this.pagingManager._makePageForHtmlId(node.htmlId,node._setFocus,node);  // for all other events set the focus
                            }
                        }
                    }
                    return node;
        },

         getFocus : function() {
                          if(xfalib.view.FieldView.prototype.currentFocus)
                            return(xfalib.view.FieldView.prototype.currentFocus.model);
                          else
                            return null;
                        } ,

        playDataXml: function (xmlDocument) {
            var rootElement;
            if(_.isUndefined(document.evaluate)) {
                // need to do it here since XPathResult is also undefined in IE
                wgxpath.install();
            }
            if(_.isString(xmlDocument)) {
                this._xfa().Logger.info("xfa", "xmlDocument is of type string. converting it to document");
                xmlDocument = $.parseXML(xmlDocument);
            }
            rootElement = xfalib.ut.XMLUtils.getXFARootFormElementFromXML(xmlDocument);
            this._xfa().form._playDataXML(rootElement, rootElement, "");
        },

        playJson : function(xfaJsonModel) {
            var formDom =  _.find(xfaJsonModel.children,
                function(child){
                    return child._class == "form";
                }
            );
            this._xfa().form.playJson(formDom);
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_REFRESH,
                this,"jsonModel",null,this._xfa().form.jsonModel);
            this.trigger(evnt.name,evnt);
        },

        runServerScript : function(options) {
            options = options|| {};
            var xfaDiff;
            if (window.FD && window.FD.isToggleEnabled("FT_FORMS-14224")) {
                xfaDiff = this._xfa()._computeJsonDiff(3).jsonDifference;
            } else {
                xfaDiff = this._xfa()._computeJsonDiff(0).jsonDifference;
            }
            var xfaDomString = JSON.stringify(xfaDiff);
           //clone the object to avoid polluting the context
            var params = _.extend({
                    formDom: xfaDomString,
                    packet: 'form'
                },
                options,
                xfalib.runtime.renderContext);

            var serverScriptSuccessHandler = function(result){
                this.playJson(result); //result will be a JSON object so just play it.
            };

            if(options.contextSom && options.activity)
            {
                var that = this;
                window.formBridge._invokeAtServer({
                    data: params,
                    success:_.bind(serverScriptSuccessHandler,this),
                    error: function(xhr,txtStatus,errorThrown) {
                        var msg
                        switch(xhr.status) {
                            case 0:
                                msg = xfalib.locale.LogMessages["ALC-FRM-901-008"];
                                that._xfa().Logger.error("xfa", msg + " " + xhr.statusText);
                                break;
                            default:
                                msg = xfalib.locale.LogMessages["ALC-FRM-901-001"];
                                that._xfa().Logger.error("xfa", msg + " " + xhr.statusText);
                                break;
                        }
                        that.messageBox(msg);
                    }
                });
            }
        },

        _validate : function(options) {
            var _options = options || {},
                valMessages = _options.valMessages || [];
            var valid = this._xfa().form._validate(valMessages);
            if(valid)
                return true;

            var errors = "";
            var warnings = "";

            for(var i=0; i < valMessages.length; i++)
            {
                var msg = null;
                if(msg = valMessages[i])
                {
                    if(msg.severity == "error") {
                        errors = errors + msg.message + "\r\n";
                    }
                    if(msg.severity == "warning"){
                        warnings = warnings + msg.message + "\r\n";
                    }
                }
            }
            if(errors)
            {
                var that = this;
                var msg = "  The form could not be submitted because "+valMessages.length +" errors were found"
                if($("#wb-main-in").length){
                    if(!$("#xfa-errorMessages").length){
                        $("#wb-main-in").prepend("<div id ='xfa-errorMessages'></div>");
                    }
                    $("#xfa-errorMessages").empty().text(msg).append("<ul id='xfa-errorList'></ul>");
                    _.each(valMessages,function(elem) {
                        $("<a></a>").appendTo($("<li></li>").appendTo('#xfa-errorList'))
                                         .text(elem.message)
                                          .click(
                                                function() {
                                                    return that.setFocus(elem.ref);
                                                });
                    })
                    if(valMessages.length ==0)
                        $("#xfa-errorMessages").hide();
                    else
                        $("#xfa-errorMessages").show();
                }
                this.setFocus(valMessages[0].ref);
                return false;
            }
            else if(warnings)
            {
                this.messageBox(warnings, xfalib.locale.Strings.warning, 1, 0);   //TODO :Should  be ok/cancel
                return true;
            }
        },

        /**
         * Helper function for currentDateTime
         *
         * @function
         */
        _padzero : function(n) {
            return n < 10 ? '0' + n : n;
        },

        /**
         * Helper function for currentDateTime
         *
         * @function
         */
        _pad2zeros : function(n) {
            if (n < 100) {
                n = '0' + n;
            }
            if (n < 10) {
                n = '0' + n;
            }
            return n;
        },

        /**
        * The function Returns current date and time in [m]m/[d]d/yy [H]H:[M]M (A|P)M format
        *
        * @function
        */
        currentDateTime : function() {
            var now = new Date(),
                    curYear = now.getFullYear() +'',
                    curMonth = now.getMonth()+1 +'',
                    curDate = now.getDate() +'',
                    curHour = now.getHours() +'',
                    curMin = now.getMinutes() +'',
                    curSec = now.getSeconds() +'';

            return (curYear + this._padzero(curMonth) + this._padzero(curDate) + 'T' +
                    this._padzero(curHour) + this._padzero(curMin) + this._padzero(curSec));
        },

        /**
         * Helper function for currentDateTime
         *
         * @function
         */
        _toISOString : function(d) {
            return d.getUTCFullYear() + '-' +  this._padzero(d.getUTCMonth() + 1) + '-' +
                this._padzero(d.getUTCDate()) + 'T' + this._padzero(d.getUTCHours()) + ':' +
                this._padzero(d.getUTCMinutes()) + ':' + this._padzero(d.getUTCSeconds()) + '.' + this._pad2zeros(d.getUTCMilliseconds()) + 'Z';
        },

        /**
         * The function Returns current date and time in ISO 8601 format
         *
         * @function
         */
        _currentDateTime : function() {
            var now = new Date();
            return(this._toISOString(now));
        }

    });

    Host.platforms = [["Win","Windows"],["Mac"],["iPhone","iPhone/iPod"],["iPad"],["Linux"],["Unknown"]];

    Host.defineProps({
        "appType" : {
            get : function() {
                return "HTML 5";
            }
        },

        "currentPage" : {
            get : function() {
                if(this.pagingManager)
                    return(this.pagingManager.currentPage());
            },
            set : function(page) {
                var currentPage = 0,
                    lastPage = 0;
                page = parseInt(page);
                if(this.pagingManager) {
                    currentPage = this.pagingManager.currentPage();
                    lastPage = this.pagingManager.pageCount();
                }

                if(page < 0)
                    page = 0;
                else if(page >= lastPage)
                    page =  (lastPage > 0) ? lastPage -1 : 0;

                var $pages = $(".page");

                if( page > $pages.length-1 ) {  // not all pages rendered yet
                    if(this.pagingManager) {
                        while(this.pagingManager.hasMorePages() && currentPage <= page){
                            this.pagingManager.renderNextPage();
                            currentPage++;
                        }
                    }
                    $pages = $(".page");   // select newly rendered pages
                }

                var a = $($pages[page]);
                window.scrollTo(0,a.offset().top) ;
            }
        },

        "name" : {
            get : function() {
                return this._browserDetect();
            }
        },

        "variation" : {
            get : function() {

            }
        },

        "numPages" : {
            get : function() {
                if(this.pagingManager)
                    return(this.pagingManager.pageCount());
            }
        },

        "platform" : {
            get : function() {
                var arr = Host.platforms;
                if (!this.mPlatform) {
                    for(var i = 0;i<arr.length;i++)
                          if(~navigator.platform.indexOf(arr[i][0]))
                                break;
                    i = i == arr.length ? i - 1 :i;
                    this.mPlatform =  arr[i][arr[i].length-1];
                }
                return this.mPlatform
            }
        },

        "title" : {
            get : function() {
                return document.title;
            },
            set : function(title) {
            	title = this.validateInput(title, "string");
                document.title = title;
            },
            enumerable : true
        },

        "version" : {
            get : function() {
                return "1.0";
            }
        },


        "calculationsEnabled" : {
            get : function() {
                return this.mCalculationsEnabled;
            },
            set : function(sCalculationsEnabled) {
            	//sCalculationsEnabled = this.validateInput(sCalculationsEnabled, "string");
                var sOriginalValue = this.mCalculationsEnabled;
                this.mCalculationsEnabled = sCalculationsEnabled;
                if (!sCalculationsEnabled) {
                    //this.xfa._rootSubform._clearMessages(); TODO: Clear Calculation messages
                } else if (sCalculationsEnabled && (sOriginalValue == false)) {
                    this._xfa().form.execCalculate();
                }
            }
        },

        "validationsEnabled" : {
            get : function() {
                return this.mValidataionsEnabled;
            },
            set : function(sValidationsEnabled) {
            	//sValidationsEnabled = this.validateInput(sValidationsEnabled, "string");
                var sOriginalValue = this.mValidataionsEnabled;
                this.mValidataionsEnabled = sValidationsEnabled;
                if (!sValidationsEnabled) {
                    //this.xfa._rootSubform._clearMessages(); TODO: Clear Validation messages
                } else if (sValidationsEnabled && (sOriginalValue == false)) {
                    this._xfa().form._validate();
                }
            }
        }

    });
})(_, xfalib, $);







(function (_, $, xfalib) {
    var XfaTemplateCache = xfalib.script.XfaTemplateCache = xfalib.ut.Class.extend({

        initialize: function () {
            XfaTemplateCache._super.initialize.call(this);
            this._lastID = (new Date()).getTime(); //TODO: Get a better scheme
            this._nodeCache = {};        // live cache
            this._t0JsonNodeCache = {}; // initial cache
            this.idMap = {};           //--map to get the field instance of the corresponding field-id

            var jsonString = JSON.stringify(this.options.initialFormDom), //We create copy of initial form dom via JSON api instead of this.copyObject since that is fast
                initialFormDomCopy = JSON.parse(jsonString),    //Create copy of initial form dom to guard against future modifications
                formDomTemplate = {};   //Copy holding formDomTemplate

            this.copyObject(initialFormDomCopy, formDomTemplate, {"exceptions": ["children"]});
            //Generate template
            this._processTemplate(formDomTemplate, initialFormDomCopy, false);
            var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
            //To maintain backward compatibility
            if (behaviorConfig.isOn('stripInitialFormDom') || behaviorConfig.isOn('mfStripInitialFormDom')) {
                xfalib.ut.XfaUtil.prototype.stripObject(this._t0JsonNodeCache[initialFormDomCopy.extras.htmlId].initialRef,
                                                        ['_class', 'name', 'htmlId', 'presence', 'min', 'max']);
            }
        },

        getTemplateRef: function (htmlId) {
            if (this._nodeCache.hasOwnProperty(htmlId))
                return this._nodeCache[htmlId].templateRef;
            else if (this._t0JsonNodeCache.hasOwnProperty(htmlId))
                return this._t0JsonNodeCache[htmlId].templateRef;
            else
                return null;
        },

        getInitialFormDomRef: function (htmlId) {
            if (this._t0JsonNodeCache.hasOwnProperty(htmlId))
                return this._t0JsonNodeCache[htmlId].initialRef;
            else
                return null;
        },

        getModel: function (htmlId) {
            if (this._nodeCache.hasOwnProperty(htmlId))
                return this._nodeCache[htmlId].model;
            else
                return null;
        },

        putModel: function (model, jsonTemplate) {
            this._processModel(jsonTemplate, model);
        },

        removeModel: function (htmlId) {
            if (this._nodeCache.hasOwnProperty(htmlId))
                delete this._nodeCache[htmlId];
        },

        _processTemplate: function (jsonTemplate, jsonModel, canRepeat) {
            var templateId = null;
            if (this.getOrElse(jsonTemplate, "extras.htmlId", null) == null) {
                jsonTemplate.extras = jsonTemplate.extras || {};
                jsonTemplate.extras.htmlId = "CL_" + (++this._lastID);
                templateId = jsonTemplate.extras.htmlId;
            }
            if (this.getOrElse(jsonModel, "extras.htmlId", null) == null) {
                jsonModel.extras = jsonModel.extras || {};
                if (templateId != null)
                    jsonModel.extras.htmlId = templateId;
                else
                    jsonModel.extras.htmlId = "CL_" + (++this._lastID);
            }
            this._t0JsonNodeCache[jsonModel.extras.htmlId] = {templateRef: jsonTemplate, initialRef: jsonModel};

            if (!canRepeat && !_.contains(["area", "pageSet", "pageArea", "subform", "subformSet", "contentArea", "exclGroup", "form"], jsonModel._class)) {
                //Process it's child only if that can repeat or it can have paintable children. This is badly written check. Need to re-code this.
                return;
            }

            var lastIM = null;
            var lastChildSF = false;
            var childTemplateIndex = -1;
            _.each(jsonModel.children,
                function (childNode, i) {
                    if (this.matchJsonType(childNode, "instanceManager")) {
                        lastIM = childNode;
                    }

                    if (!lastChildSF) {   //If last child was not subform then increase template index
                        childTemplateIndex = childTemplateIndex + 1;
                    } else if (!this.xfaUtil().isRepeatabeEl(childNode._class)) { //Else increase template index only for non-subform
                        childTemplateIndex = childTemplateIndex + 1;
                    }

                    var childRepeat = canRepeat;
                    if (this.xfaUtil().isRepeatabeEl(childNode._class)) {
                        childRepeat = childRepeat || parseInt(this.getOrElse(lastIM, "max", xfalib.script.Occur.prototype._defaults.max)) < 0 ||
                            (parseInt(this.getOrElse(lastIM, "min", xfalib.script.Occur.prototype._defaults.min)) < parseInt(this.getOrElse(lastIM, "max", xfalib.script.Occur.prototype._defaults.max)));
                        lastChildSF = true;
                    }
                    else
                        lastChildSF = false;

                    jsonTemplate.children = jsonTemplate.children || [];
                    var childTemplate = jsonTemplate.children[childTemplateIndex];
                    if (!childTemplate) {
                        childTemplate = {
                            _class: childNode._class,
                            name: childNode.name,
                            extras: childNode.extras || {}
                        };
                        if (childRepeat) { //For repeatable child copy all properties
                            this.copyObject(childNode, childTemplate, {exceptions: ["children"], keepReference: false});
                        }
                        jsonTemplate.children.push(childTemplate);
                    }
                    this._processTemplate(childTemplate, childNode, childRepeat);
                }, this);
        },

        _processModel: function (jsonTemplate, model) {
            if (model.htmlId == null) {
                model.htmlId = "CL_" + (++this._lastID);
            }
            this._nodeCache[model.htmlId] = {templateRef: jsonTemplate, model: model};
            var childTemplateIndex = -1;
            var lastChildSF = false;
            _.each(model.children,
                function (childNode, i) {
                    if (!lastChildSF) {   //If last child was not subform then increase template index
                        childTemplateIndex = childTemplateIndex + 1;
                    } else if (!(childNode instanceof xfalib.script.Subform)) { //Else increase template index only for non-subform
                        childTemplateIndex = childTemplateIndex + 1;
                    }

                    lastChildSF = childNode instanceof xfalib.script.Subform;

                    var childTemplate = jsonTemplate.children ? jsonTemplate.children[childTemplateIndex] : undefined
                    if (childTemplate)
                        this._processModel(childTemplate, childNode);
                }, this);
        },

        matchJsonType: xfalib.ut.XfaUtil.prototype.matchJsonType

    });

})(_, $, xfalib);
/**
 * @package xfalib.script.Xfa
 * @import xfalib.script.Model
 * @import xfalib.ut.Logger
 * @import xfalib.script.Host
 * @import xfalib.script.XfaModelEvent
 * @fileOverview The file creates the XFA Class required for XFA library
 * @version 0.0.1
 */

(function (_, xfalib) {
    /**
     * @class The class represents the XFA Object
     * @extends com.adobe.xfa.scripting.Model
     * @property {com.adobe.xfa.scripting.Host} host Object of the host class
     */
    var Xfa = xfalib.script.Xfa = xfalib.script.Model.extend({
        msClassName: "xfa",
        initialize: function () {
            xfalib.runtime.xfa = this;                           //TODO: Handle anithing being used before super
            xfalib.runtime["$xfa"] = this;
            this.$layout = this.layout = new xfalib.script.Layout({"jsonModel": {}});
            var logConf = window.formBridge.registerConfig("LoggerConfig").data || {};
            var renderContextCopy = {};
            this.copyObject(xfalib.runtime.renderContext, renderContextCopy, {"exceptions": ["data"]})
            xfalib.runtime.xfa.Logger = new xfalib.ut.Logger({
                "jsonModel": logConf,
                logServiceProxy: this.getOrElse(window.formBridge.userConfig["submitServiceProxyConfig"], "logServiceProxy", ""),
                renderContext: renderContextCopy,
                contextPath: window.formBridge.userConfig["contextPath"]
            });
            xfalib.runtime.xfa.ErrorManager = this.getOrElse(window.formBridge.userConfig["errorConfig"],new xfalib.view.util.ErrorManager)
            xfalib.script.Xfa.Instance = this;          //TODO: Singleton reqd?
            this._submitButtons = [];
            this._modelInitialize = 'UNINITIALIZED'; // can be set to 'INITIALIZED' or ''INITIALIZING'
            this.moContextNodes = [];
            this.moCalculateEventStack = [];
            this.moCalculateEventNode = null;
            this.host = new xfalib.script.Host();
            xfalib.runtime["$host"] = this.host;
            this.countError = 0;
            this.dataNodes = {};
            this._templateSchema = new xfalib.template.TemplateSchema();
            this.moContextScriptEvent = null; // will hold current event for which script is executing
            this.Queue = {"calc": [], "calcindex": 0, "validate": [], "validateindex": 0, calcCount: {},
                "setfocus": [], "setfocusindex": 0};

            // to clear all _moContext-s cached in eventContainerNode-s, after subform.addInstance or subform.removeInstance
            xfalib.runtime.xfa._clearAllMoContexts = function () {
                function clearMoContextVisitor(target) {
                    if (target instanceof xfalib.script.EventContainerNode) {
                        target._moContext = null;
                    }
                }
                xfalib.runtime.xfa.form._getRootSubform()._visitAllmoChildren(clearMoContextVisitor);
            };

            //Create Form Child
            var formJson = _.find(this.jsonModel.children, function (child) {
                return child._class == "form";
            });
            this._xfaTemplateCache = new xfalib.script.XfaTemplateCache({initialFormDom: formJson});

            //We call Super later at this stage since we need to initialize few variables which are required while initializing children
            Xfa._super.initialize.call(this);

            //get the child from children models that are already created.
            this.form = _.find(this.children, function (child) {
                return child._isForm();
            });
            this._xfaTemplateCache.putModel(this.form,
                this._xfaTemplateCache.getTemplateRef(this.getOrElse(formJson, "extras.htmlId", {}))
            );

            //Note: since we do not support template currently, we workarond by pointing template node to form node which would have similar structure in most cases.
            xfalib.runtime['$template'] = this.template = xfalib.runtime['$form'] = this.form;
            xfalib.runtime['template'] = xfalib.runtime['form'] = this.form;

            //Create Config Child. Notice that it is not XFA Node model, just a json child for now.
            this.config = _.find(this.jsonModel.children, function (child) {
                return child._class == "config";
            });
            xfalib.runtime['$config'] = this.config;

            //Create localeSet Child. Notice that it is not XFA Node model, just a json child for now.
            this.localeSet = this.jsonModel.localeSet;
            this.defaultLocale = "en_US"; //TODO: read from jsp

            //Once everything is set up, now is the time to set parent access
            this.form._calculateEffectiveAccess();
            this.form._calculateEffectivePresence();
            this.calculateRunning = false;
            this.validateRunning = false;
            this.versionConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
        },

        /**
         * Evaluates the specified SOM expression, beginning with the current XML form
         * object model object, and returns the value of the object specified in the SOM
         * expression
         * @Overrides
         * @function
         */
        resolveNode: function () {
            if (arguments.length == 1)
                return Xfa._super.resolveNode.call(this, this._contextNode() || this, arguments[0]);
            else
                return Xfa._super.resolveNode.call(this, arguments[0], arguments[1]);
        },

        /**
         * Evaluates the specified SOM expression, beginning with the current XML form
         * object model object, and returns the value of the object specified in the SOM
         * expression
         * @Overrides
         * @function
         */
        resolveNodes: function () {
            if (arguments.length == 1)
                return Xfa._super.resolveNodes.call(this, this._contextNode(), arguments[0]);
            else
                return Xfa._super.resolveNodes.call(this, arguments[0], arguments[1]);
        },

        _newSubmitButton: function (elem) {
            if (!~this._submitButtons.indexOf(elem))     //TODO: What is this. Add a comment
                this._submitButtons.push(elem);
        },

        _hideSubmitButtons: function (elem) {
            for (var i = 0; i < this._submitButtons.length; i++) {
                this._submitButtons[i].presence = "hidden";
            }
        },

        /**
         * The function pushes a new Calculate Event Node into the Calculate Stack
         * @function
         * @param {com.adobe.xfa.scripting.Node} node current context node
         * @private
         */
        _pushCalculateEventNode: function (node) {
            this.moCalculateEventStack.push(node);
            this.moCalculateEventNode = node;
        },

        /**
         * The function pushes a new XFA Node in the current context
         * @function
         * @param {com.adobe.xfa.scripting.Node} node current context node
         * @private
         */
        _pushContextNode: function (node) {
            this.moContextNodes.push(node);
        },

        /**
         * The function pops Calculate Event Node from the stack of context nodes
         * @function
         * @private
         */
        _popCalculateEventNode: function () {
            this.moCalculateEventStack.pop();
            this.moCalculateEventNode = null;
        },

        /**
         * The function pops a XFA Node from the stack of context nodes
         * @function
         * @private
         */
        _popContextNode: function () {
            this.moContextNodes.pop();
        },

        _contextNode: function () {
            var len = this.moContextNodes.length;
            if (len > 0)
                return this.moContextNodes[len - 1]
            return null;
        },

        _isXFAContainerNode: function () {
            return true;
        },

        _getSomExpression: function () {
            return this.getAttribute("name") + "[" + this.index + "]";
        },

        _getLocaleSymbols: function (locale, symbol) {
            var ret = null;
            var newSymbol = "locales." + locale + "." + symbol;
            ret = this.getOrElse(this.localeSet, newSymbol, xfalib.ut.XfaUtil.prototype.getDefaultLocaleProperty(symbol));
            if (!ret) {
                xfalib.runtime.xfa.Logger.error("xfa", "unable to find " + symbol + " for locale " + locale + "in localeSet");
            }
            return ret;
        },

        setSubformFocus: function (subform) {
            var oldSubform = this.currentSubform;
            this.currentSubform = subform;
            var views = [];
            if (oldSubform) {
                var pSubform = subform;
                while (pSubform) {
                    views.push(pSubform);
                    pSubform = pSubform.parent;
                }
                while (oldSubform && views.indexOf(oldSubform) == -1) {
                    oldSubform.execEvent("exit");
                    oldSubform = oldSubform.parent;
                }
            }
        },

        createDataNode: function (id, model) {
            if (id) {
                var dn = this.dataNodes[id] || xfalib.script.XfaModelRegistry.prototype.createDataNode(id);
                dn.addField(model);
                this.dataNodes[id] = dn;
            }
        },

        queueCalcEvent: function (oListener) {
            if (!this.host.calculationsEnabled)
                return;
            var q = this.Queue["calc"];
            var som = oListener.somExpression;
            for (var i = 0; i < q.length; i++) {
                var item = q[i];
                if (oListener == item) {
                    if (i < this.Queue.calcindex) {
                        if (this.Queue.calcCount[som] === 10)
                            return;
                    }
                    else
                        return;
                }
            }
            this.Queue.calcCount[som] = this.Queue.calcCount[som] || 0;
            this.Queue.calcCount[som]++;
            q.push(oListener);
        },

        queueValidateEvent: function (oNode) {
            if (!this.host.validationsEnabled)
                return;
            if (!~this.Queue["validate"].indexOf(oNode))
                this.Queue["validate"].push(oNode);
        },

        queueFocusEvent: function (context, som) {
            this.Queue["setfocus"].push({'context': context, 'som': som});
        },

        runQueue: function (queue, evnt) {
            if (queue !== "calc" && queue !== "validate")
                return;
            if (queue == "calc" && !this.host.calculationsEnabled)
                return;
            if (queue == "validate" && !this.host.validationsEnabled)
                return;
            var Q = this.Queue[queue];
            var ind = this.Queue[queue + "index"];
            for (var i = ind; i < Q.length; i++) {
                this.Queue[queue + "index"]++;
                if (evnt === "validate") {
                    Q[i]._validate([]);
                }
                else {
                    Q[i].execEvent(evnt);
                }
            }
        },

        runCalcAndValidate: function () {
            this._pushContextNode(this.form);
            this.runCalcs();
            this.runValidates();
            this.runSetFocuses();
            this.Queue["calc"] = [];
            this.Queue.calcindex = 0;
            this.Queue.calcCount = {};
            this.Queue["validate"] = [];
            this.Queue.validateindex = 0;
            this.Queue["setfocus"] = [];
            this.Queue.setfocusindex = 0;
            this._popContextNode();
        },

        runCalcs: function (start) {
            if (typeof start != "undefined" && start === "true")
                this.Queue.calcindex = 0;
            this.calculateRunning = true;
            this.runQueue("calc", "calculate");
            this.calculateRunning = false;
        },

        runValidates: function () {
            this.validateRunning = true;
            this.runQueue("validate", "validate")
            this.validateRunning = false;
        },

        runSetFocuses: function () {
            var Q = this.Queue["setfocus"],
                index = this.Queue["setfocusindex"];
            for (var i = index; i < Q.length; i++) {
                this.Queue["setfocusindex"]++;
                var som = Q[i]['som'],
                    node = som,
                    context = Q[i]['context'];
                if (typeof som == "string")
                    node = context._xfa().resolveNode(som);
                if (node != null) {
                    if (context.pagingManager) {
                        if (navigator.userAgent.match(/iPad/i) == null) {
                            xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(
                                setTimeout(function () {
                                    context.pagingManager._makePageForHtmlId(node.htmlId, node._setFocus, node);
                                })
                            );  // just give browser enough time to register the keypress
                        } else {
                            context.pagingManager._makePageForHtmlId(node.htmlId, node._setFocus, node); // $.focus() doesn't work inside setTimeout in iPad
                        }
                    }
                }
            }
        },

        _computeJsonDiff: function (diff_level) {
            var formDiff = this.form._computeJsonDiff(diff_level);
            var dest = {
                _class: this.className,
                name: "xfa",
                versionNS: this.jsonModel.versionNS,
                children: [formDiff.jsonDifference]
            };

            return { "changed": true,
                "jsonDifference": dest
            };
        }
    });

    Xfa._defaultLocale = {
        "calendarSymbols": {
            "monthNames": ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
            "abbrmonthNames": ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
            "dayNames": ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
            "abbrdayNames": ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
            "meridiemNames": ["AM", "PM"],
            "eraNames": ["BC", "AD"]
        },
        "datePatterns": {
            "full": "EEEE D MMMM YYYY",
            "long": "D MMMM YYYY",
            "med": "DD-MMM-YY",
            "short": "DD/MM/YY"
        },
        "timePatterns": {
            "full": "h:MM:SS A Z",
            "long": "h:MM:SS A Z",
            "med": "h:MM:SS A",
            "short": "h:MM A"
        },
        "dateTimeSymbols": "GyMdkHmsSEDFwWahKzZ",
        "numberPatterns": {
            "numeric": "z,zz,zz9.zzz",
            "currency": "$ z,zz,zz9.99",
            "percent": "z,zz,zz9%"
        },
        "numberSymbols": {
            "decimal": ".",
            "grouping": ",",
            "percent": "%",
            "minus": "-",
            "zero": "0"
        },
        "currencySymbols": {
            "symbol": "$",
            "isoname": "USD",
            "decimal": "."
        },
        "typefaces": {}
    }
})(_, xfalib);
/**
 * @package xfalib.script.XfaModelRegistry
 * @import xfalib.ut.Class
 */
(function(_, xfalib){
    var XfaModelRegistry = xfalib.script.XfaModelRegistry = xfalib.ut.Class.extend({

        _classToFactoryMap : {
            "script" : "createScript",
            "exclGroup" : "createExclusionGroup",

            "arc" : "createNodeValue",
            "boolean": "createNodeValue",
            "date": "createNodeValue",
            "dateTime": "createNodeValue",
            "decimal": "createNodeValue",
            "exData": "createNodeValue",
            "float": "createNodeValue",
            "image": "createNodeValue",
            "integer": "createNodeValue",
            "line": "createNodeValue",
            "rectangle": "createNodeValue",
            "text": "createNodeValue",
            "time": "createNodeValue"

        },

        createModel : function(jsonModel){
            var model = null;
            var elClass = jsonModel._class.charAt(0).toUpperCase() + jsonModel._class.substr(1);
            var factoryFnName = "create" + elClass ;
            if(this._classToFactoryMap[jsonModel._class]){
                factoryFnName = this._classToFactoryMap[jsonModel._class];
            }
            if(this[factoryFnName])
                model = this[factoryFnName].call(this, jsonModel);


            if(!model && xfalib.script.dom[elClass]){
                model = new xfalib.script.dom[elClass]({"jsonModel" : jsonModel});
            }

            if(!model) {
                model = new xfalib.script.Node({"jsonModel" : jsonModel});
            }
            return model;
        },

        createXfa : function(json){
            return new xfalib.script.Xfa({"jsonModel" : json});
        },

        createForm : function(json){
            return new xfalib.script.Form({"jsonModel" : json});
        },

        createConfig : function(json){
            return json;      //No seperate model API for config for now
        },

        createTextField : function(field) {
            return new xfalib.script.Field({"jsonModel" : field});
        },

        createImageField : function(field) {
            return new xfalib.script.Field({"jsonModel" : field});
        },

        createDateTimeField : function(field) {
            return new xfalib.script.DateTimeField({"jsonModel" : field});
        },

        createNumericField : function(field) {
            return new xfalib.script.NumericField({"jsonModel" : field});
        },

        createChoiceListField : function(field) {
            return new xfalib.script.ChoiceListField({"jsonModel" : field});
        },

        createButtonField : function(field) {
            return new xfalib.script.ButtonField({"jsonModel" : field});
        },

        createCheckButtonField : function(field) {
            return new xfalib.script.CheckButtonField({"jsonModel" : field});
        },

        createTextDraw : function(draw) {
            return new xfalib.script.Draw({"jsonModel" : draw});
        },

        createInstanceManager : function(oInstanceManager) {
            return new xfalib.script.InstanceManager({"jsonModel" : oInstanceManager});
        },

        createPageSet: function(vPageSet) {
            return new xfalib.script.PageSet({"jsonModel" : vPageSet});
        },

        createPageArea: function(vPageArea) {
            return new xfalib.script.PageArea({"jsonModel" : vPageArea});
        },

        createContentArea: function(vContentArea) {
            return new xfalib.script.ContentArea({"jsonModel" : vContentArea});
        },

        createExclusionGroup : function(exclGroup) {
            return new xfalib.script.ExclusionGroup({"jsonModel" : exclGroup});
        },

        createSubform: function(vSubform) {
            return new xfalib.script.Subform({"jsonModel" : vSubform});
        },

        createArea: function(vArea) {
            return new xfalib.script.Area({"jsonModel" : vArea});
        },

        createSubformSet: function(vSubformSet) {
            return new xfalib.script.SubformSet({"jsonModel" : vSubformSet});
        },

        createVariables: function(vVariables) {
            return new xfalib.script.Variables({"jsonModel" : vVariables});
        },

        createScript: function(vScript) {
            if(vScript._parentClass && vScript._parentClass == "variables"){
                return new xfalib.script.dom.ScriptObject({"jsonModel" : vScript});
            }
            else {
                return new xfalib.script.dom.Script({"jsonModel" : vScript});
            }
        },

        createField : function(field) {
            var t = null;
            var childType = this.getOrElse(this.xfaUtil().getUiOneOfChildTag(field), "").toLowerCase();
            switch (childType) {
                case "datetimeedit":
                    t =this.createDateTimeField(field)
                    break;
                case "textedit":
                    t = this.createTextField(field);
                    break;
                case "imageedit":
                    t = this.createImageField(field);
                    break;
                case "numericedit":
                    t = this.createNumericField(field);
                    break;
                case "choicelist":
                    t = this.createChoiceListField(field);
                    break;
                case "button":
                    t = this.createButtonField(field);
                    break;
                case "checkbutton":
                    t = this.createCheckButtonField(field);
                    break;
                default:
                    //xfa.Logger.warn("unknown uiType for the field " + field.ui.type + " <"
                    //    + field.name + "> Creating a TextField instead");
                    t = this.createTextField(field);
                    break;
            }
            return t;
        },

        createDraw : function(draw) {
            var t = null;
            var childType = this.getOrElse(this.xfaUtil().getUiOneOfChildTag(draw), "").toLowerCase();
            switch (childType) {
                case "textedit":
                    t = this.createTextDraw(draw);
                    break;
                default:
                    //xfa.Logger.warn("unknown uiType for the draw " + draw.ui.type + " <"
                    //    + draw.name + "> Creating a Static Text instead");
                    t = this.createTextDraw(draw);
                    break;
            }
            return t;
        },

        createSomExpression : function(sExpression, nDefaultOccurrence, bIgnorePredicate) {
            var options = {
                expression : sExpression,
                defaultOccurrence : nDefaultOccurrence,
                ignorePredicate : bIgnorePredicate
            }
            return new xfalib.script.SOMExpression(options);
        },

        createValue: function(valueJson) {
            return new xfalib.script.dom.Value({"jsonModel" : valueJson});
        },

        createNodeValue : function(valueJson) {
            //ToDo : this is a stop grap measure till we find a way to handle default valueJson
            valueJson = valueJson || {_class: "", rawValue: ""};
            var valType = valueJson._class.toLowerCase();
            switch (valType) {
                case "text":
                    return new xfalib.script.TextValue({"jsonModel" : valueJson});
                case "integer":
                    return new xfalib.script.IntegerValue({"jsonModel" : valueJson});
                case "decimal":
                	return new xfalib.script.DecimalValue({"jsonModel" : valueJson});
                case "float":
                    return new xfalib.script.FloatValue({"jsonModel" : valueJson}); 
                case "exdata":
                    return new xfalib.script.ExDataValue({"jsonModel" : valueJson});
                case "date":
                    return new xfalib.script.DateValue({"jsonModel" : valueJson});
                case "image":
                    return new xfalib.script.ImageValue({"jsonModel" : valueJson});
                case "script":
                    return this.createScript(valueJson);
                default:
                    //xfa.Logger.warn("unknown value type " + valueJson.type + " for element <"
                    //    + this.name + ">");
                    return new xfalib.script.NodeValue({"jsonModel" : valueJson});
            }
        },

        createDataNode: function(id) {
            return new xfalib.script.DataNode({"jsonModel" : {"id":id}});
        }

    });

})(_, xfalib);
(function(_, xfalib){
    var App = xfalib.acrobat.App =  xfalib.ut.Class.extend({
        initialize : function() {
            App._super.initialize.call(this);
            xfalib.runtime.app = this;
            this._version = window.formBridge.getBridgeVersion();

        },

        alert: function(cMsg) {
            return window.alert(cMsg);
        },

        beep: function(nType) {

        },


        execDialog: function(dialog) {

        },

        launchURL: function(url, bNewFrame) {
            if(url.search("http") == -1)
                url = "http://" + url ;
            if(bNewFrame != true) {
                window.open(url) ;
            }
            else
                window.location = url;
        },

        setTimeOut: function(cExpr, nMilliseconds) {
            try {
                var fn = new Function(this._within(cExpr));
                return window.setTimeout(function() {
                     fn.call(xfalib.runtime.Document);
                }, nMilliseconds);
            } catch(ex) {
                console.log(ex);
            }
        },

        setInterval: function(cExpr, nMilliseconds) {
            try {
                var fn = new Function(this._within(cExpr));
                return window.setInterval(function() {
                    fn.call(xfalib.runtime.Document);
                }, nMilliseconds);
            } catch(ex) {
                console.log(ex);
            }
        },

        clearTimeOut: function(oTime) {
            window.clearTimeout(oTime);
        },

        clearInterval: function(oInterval) {
            window.clearInterval(oInterval);
        },

        eval: function(script) {
            window.eval(this._within(script));
        },

        _within: function(script){
            var string  =   "try {\n" +
                                "with(xfalib.runtime.Document) {\n" +
                                    "with(xfalib.runtime) {\n" +
                                        script +"\n" +
                                    "}\n" +
                                "}\n" +
                            "} catch(ex) {\n" +
                                "console.log(ex)\n" +
                            "}";
            return string;
        }

    });

    App.defineProps({
        "activeDocs" : {
            get : function() {
                return ([]);
            }
        },

        "calculate" : {
            get : function() {
                return (true);
            }
        },

        "constants" : {
            get : function() {
                return ({align:{}});
            }
        },

        "focusRect" : {
            get : function() {
                return (true);
            }
        },

        "formsVersion" : {
            get : function() {
                return (this._version);
            }
        },

        "fromPDFConverters" : {
            get : function() {
                return ([]);
            }
        },

        "fs" : {
            get : function() {
                return ({isFullScreen: false});
            }
        },

        "fullscreen" : {
            get : function() {
                return (false);
            }
        },

        "language" : {
            get : function() {
                if(navigator.language.substr(0,2) === "en")
                    return ("ENU");
                return ("ENU");
            }
        },

        "platform" : {
            get : function() {
                if(navigator.appVersion.indexOf("Win") != -1)
                    return ("WIN");
                if(navigator.appVersion.indexOf("Mac") != -1)
                    return ("MAC");
                return ("UNIX");
            }
        },

        "viewerType" : {
            get : function() {
                return ("Exchange-Pro");
            }
        },

        "viewerVariation" : {
            get : function() {
                return ("Full");
            }
        },

        "viewerVersion" : {
            get : function() {
                return (this._version);
            }
        }
    })

})(_, xfalib);

(function(_, xfalib){
    var Console = xfalib.acrobat.Console =  xfalib.ut.Class.extend({
        initialize : function(bRegister) {
            Console._super.initialize.call(this);
            if(bRegister)
                xfalib.runtime.console = this;
        },

        println: function() {
            //add this method to insert console where 'console' is not supported
        }
    });

})(_, xfalib);

(function(_, xfalib){
    var Acrobat = xfalib.acrobat.Acrobat =  xfalib.ut.Class.extend({
        initialize : function() {
            Acrobat._super.initialize.call(this);
            //initialize App object
            new xfalib.acrobat.App();
            //insert println inside console object
            if(typeof(console) != "undefined") {
                if(console.log)
                    console.println = console.log;
                else {
                    //register empty method
                    var con = new xfalib.acrobat.Console();
                    console.println = con.println;
                }
            }
            else {
                new xfalib.acrobat.Console(true);
            }
        }
    });

})(_, xfalib);

/**
 * Created with IntelliJ IDEA.
 * User: vdua
 * Date: 21/5/13
 * Time: 5:56 PM
 * To change this template use File | Settings | File Templates.

 /**
 * @package xfalib.script.XfaModelEvent
 * @import xfalib.script.Object
 * @fileOverview The file creates the XfaModelEvent Class required for XFA library
 * @version 0.0.1
 */
(function(_,xfalib) {

    var Field = xfalib.acrobat.Field = xfalib.ut.Class.extend({
        initialize : function() {
            Field._super.initialize.call(this);
            this._xfaField = xfalib.script.Xfa.Instance.resolveNode("xfa.form."+this.jsonModel.somExpression);
        },

        signatureInfo : function() {
            throw {message:"signatureInfo is not supported"}
        },

        setFocus: function() {
            xfalib.script.Xfa.Instance.host.setFocus(this.jsonModel.somExpression);
        }
    });

    Field.defineProps({

    })
})(_,xfalib);
/**
 * @package xfalib.script.XfaModelEvent
 * @import xfalib.script.Object
 * @fileOverview The file creates the XfaModelEvent Class required for XFA library
 * @version 0.0.1
 */
(function(_,xfalib) {

    var Doc = xfalib.acrobat.Doc = xfalib.ut.Class.extend({

        getURL: function() {
            return window.location.href;
        },

        resetForm: function(fieldArray) {
            if(!(fieldArray instanceof Array)) {
                fieldArray = [fieldArray];
            }
            this.xfa.host.resetData.apply(this.xfa.host,fieldArray);
        },

        submitForm: function() {
            this.xfa.Logger.error("xfa",xfalib.locale.LogMessages["ALC-FRM-901-006"],["submitForm"]);
        },

        getField: function(som) {
            return new xfalib.acrobat.Field({"jsonModel" : {"somExpression": som}});
        },

        importDataObject: function() {
            throw {message:"importDataObject is not supported"}
        }

    });

    Doc.defineProps({
        "xfa" : {
            get: function() {
                return xfalib.script.Xfa.Instance;
            }
        }

    })

    xfalib.runtime.Document = new xfalib.acrobat.Doc({jsonModel:{}});

})(_,xfalib);
/**
 * @package xfalib.script.XfaModelEvent
 * @import xfalib.script.Object
 * @fileOverview The file creates the XfaModelEvent Class required for XFA library
 * @version 0.0.1
 */
(function(_,xfalib) {

    var AcroEvent = xfalib.acrobat.AcroEvent = xfalib.script.XfaModelEvent.extend({
        msClassName: "acroEvent",
        initialize : function() {
            xfalib.script.XfaModelEvent._super.initialize.call(this);
            this.jsonModel.target = xfalib.runtime.Document;
        }
    });

    AcroEvent.cloneEvent = function(xfaModelEvent) {
        var copy = xfaModelEvent.copyObject(xfaModelEvent.jsonModel, {},{"exceptions":["target"]});
        return new AcroEvent({"jsonModel" : copy});
    };

})(_,xfalib);
(function (_, xfalib) {
    var AppearanceFilter = xfalib.script.dom.AppearanceFilter = xfalib.script.GenericText.extend({
        msClassName:"appearanceFilter"
    });

    AppearanceFilter.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Assist = xfalib.script.dom.Assist = xfalib.script.DOMElement.extend({
        msClassName:"assist"
    });

    Assist.defineProps({
        role:{
            get:function () {
                return this.getAttribute("role");
            },
            set:function (value) {
                this.setAttribute(value, "role");
            }
        },
        speak:{
            get:function () {
                return this.getElement("speak", 0);
            },
            set:function (value) {
                this.setElement(value, "speak");
            }
        },
        toolTip:{
            get:function () {
                return this.getElement("toolTip", 0);
            },
            set:function (value) {
                this.setElement(value, "toolTip");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Barcode = xfalib.script.dom.Barcode = xfalib.script.DOMElement.extend({
        msClassName:"barcode"
    });

    Barcode.defineProps({
        charEncoding:{
            get:function () {
                return this.getAttribute("charEncoding");
            },
            set:function (value) {
                this.setAttribute(value, "charEncoding");
            }
        },
        checksum:{
            get:function () {
                return this.getAttribute("checksum");
            },
            set:function (value) {
                this.setAttribute(value, "checksum");
            }
        },
        dataColumnCount:{
            get:function () {
                return this.getAttribute("dataColumnCount");
            },
            set:function (value) {
                this.setAttribute(value, "dataColumnCount");
            }
        },
        dataLength:{
            get:function () {
                return this.getAttribute("dataLength");
            },
            set:function (value) {
                this.setAttribute(value, "dataLength");
            }
        },
        dataPrep:{
            get:function () {
                return this.getAttribute("dataPrep");
            },
            set:function (value) {
                this.setAttribute(value, "dataPrep");
            }
        },
        dataRowCount:{
            get:function () {
                return this.getAttribute("dataRowCount");
            },
            set:function (value) {
                this.setAttribute(value, "dataRowCount");
            }
        },
        endChar:{
            get:function () {
                return this.getAttribute("endChar");
            },
            set:function (value) {
                this.setAttribute(value, "endChar");
            }
        },
        errorCorrectionLevel:{
            get:function () {
                return this.getAttribute("errorCorrectionLevel");
            },
            set:function (value) {
                this.setAttribute(value, "errorCorrectionLevel");
            }
        },
        moduleHeight:{
            get:function () {
                return this.getAttribute("moduleHeight");
            },
            set:function (value) {
                this.setAttribute(value, "moduleHeight");
            }
        },
        moduleWidth:{
            get:function () {
                return this.getAttribute("moduleWidth");
            },
            set:function (value) {
                this.setAttribute(value, "moduleWidth");
            }
        },
        printCheckDigit:{
            get:function () {
                return this.getAttribute("printCheckDigit");
            },
            set:function (value) {
                this.setAttribute(value, "printCheckDigit");
            }
        },
        rowColumnRatio:{
            get:function () {
                return this.getAttribute("rowColumnRatio");
            },
            set:function (value) {
                this.setAttribute(value, "rowColumnRatio");
            }
        },
        startChar:{
            get:function () {
                return this.getAttribute("startChar");
            },
            set:function (value) {
                this.setAttribute(value, "startChar");
            }
        },
        textLocation:{
            get:function () {
                return this.getAttribute("textLocation");
            },
            set:function (value) {
                this.setAttribute(value, "textLocation");
            }
        },
        truncate:{
            get:function () {
                return this.getAttribute("truncate");
            },
            set:function (value) {
                this.setAttribute(value, "truncate");
            }
        },
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        upsMode:{
            get:function () {
                return this.getAttribute("upsMode");
            },
            set:function (value) {
                this.setAttribute(value, "upsMode");
            }
        },
        wideNarrowRatio:{
            get:function () {
                return this.getAttribute("wideNarrowRatio");
            },
            set:function (value) {
                this.setAttribute(value, "wideNarrowRatio");
            }
        },
        encrypt:{
            get:function () {
                return this.getElement("encrypt", 0);
            },
            set:function (value) {
                this.setElement(value, "encrypt");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Bind = xfalib.script.dom.Bind = xfalib.script.DOMElement.extend({
        msClassName:"bind"
    });

    Bind.defineProps({
        match:{
            get:function () {
                return this.getAttribute("match");
            },
            set:function (value) {
                this.setAttribute(value, "match");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var BindItems = xfalib.script.dom.BindItems = xfalib.script.GenericText.extend({
        msClassName:"bindItems"
    });

    BindItems.defineProps({
        connection:{
            get:function () {
                return this.getAttribute("connection");
            },
            set:function (value) {
                this.setAttribute(value, "connection");
            }
        },
        labelRef:{
            get:function () {
                return this.getAttribute("labelRef");
            },
            set:function (value) {
                this.setAttribute(value, "labelRef");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        valueRef:{
            get:function () {
                return this.getAttribute("valueRef");
            },
            set:function (value) {
                this.setAttribute(value, "valueRef");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Bookend = xfalib.script.dom.Bookend = xfalib.script.GenericText.extend({
        msClassName:"bookend"
    });

    Bookend.defineProps({
        leader:{
            get:function () {
                return this.getAttribute("leader");
            },
            set:function (value) {
                this.setAttribute(value, "leader");
            }
        },
        trailer:{
            get:function () {
                return this.getAttribute("trailer");
            },
            set:function (value) {
                this.setAttribute(value, "trailer");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Border = xfalib.script.dom.Border = xfalib.script.DOMElement.extend({
        msClassName:"border",

        handleEvent: function (evnt) {
            if(evnt._property == 'edge.color.value') {
                //If the color is being set for first border edge, and the corner are rounded - set for all the edges
                //reason: In case of rounded corner, we divide the single edge into 4 edges, and thus when trying to set
                //the color for all of them together, only first is set - NPR-15444
                var isFirstIndex = evnt.target.parent.mnClassIndex == 0,
                    isRoundedBorder = !!(parseInt(this.corner.radius));
                if(isFirstIndex && isRoundedBorder) {
                    var index = 1,
                        edge;
                    while (edge = this.getElement('edge', index, true)) {
                        //set the value in case a different color has not been set for a different edge explicitly
                        edge.color.setAttribute(evnt.target.value,'value');
                        index++;
                    }
                }
            }
            Border._super.handleEvent.call(this, evnt);
        }
    });

    Border.defineProps({
        "break":{
            get:function () {
                return this.getAttribute("break");
            },
            set:function (value) {
                this.setAttribute(value, "break");
            }
        },
        hand:{
            get:function () {
                return this.getAttribute("hand");
            },
            set:function (value) {
                this.setAttribute(value, "hand");
            }
        },
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
            }
        },
        relevant:{
            get:function () {
                return this.getAttribute("relevant");
            },
            set:function (value) {
                this.setAttribute(value, "relevant");
            }
        },
        corner:{
            get:function () {
                return this.getElement("corner", 0);
            },
            set:function (value) {
                this.setElement(value, "corner");
            }
        },
        edge:{
            get:function () {
                return this.getElement("edge", 0);
            },
            set:function (value) {
                this.setElement(value, "edge");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        fill:{
            get:function () {
                return this.getElement("fill", 0);
            },
            set:function (value) {
                this.setElement(value, "fill");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Break = xfalib.script.dom.Break = xfalib.script.DOMElement.extend({
        msClassName:"break"
    });

    Break.defineProps({
        after:{
            get:function () {
                return this.getAttribute("after");
            },
            set:function (value) {
                this.setAttribute(value, "after");
            }
        },
        afterTarget:{
            get:function () {
                return this.getAttribute("afterTarget");
            },
            set:function (value) {
                this.setAttribute(value, "afterTarget");
            }
        },
        before:{
            get:function () {
                return this.getAttribute("before");
            },
            set:function (value) {
                this.setAttribute(value, "before");
            }
        },
        beforeTarget:{
            get:function () {
                return this.getAttribute("beforeTarget");
            },
            set:function (value) {
                this.setAttribute(value, "beforeTarget");
            }
        },
        bookendLeader:{
            get:function () {
                return this.getAttribute("bookendLeader");
            },
            set:function (value) {
                this.setAttribute(value, "bookendLeader");
            }
        },
        bookendTrailer:{
            get:function () {
                return this.getAttribute("bookendTrailer");
            },
            set:function (value) {
                this.setAttribute(value, "bookendTrailer");
            }
        },
        overflowLeader:{
            get:function () {
                return this.getAttribute("overflowLeader");
            },
            set:function (value) {
                this.setAttribute(value, "overflowLeader");
            }
        },
        overflowTarget:{
            get:function () {
                return this.getAttribute("overflowTarget");
            },
            set:function (value) {
                this.setAttribute(value, "overflowTarget");
            }
        },
        overflowTrailer:{
            get:function () {
                return this.getAttribute("overflowTrailer");
            },
            set:function (value) {
                this.setAttribute(value, "overflowTrailer");
            }
        },
        startNew:{
            get:function () {
                return this.getAttribute("startNew");
            },
            set:function (value) {
                this.setAttribute(value, "startNew");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var BreakAfter = xfalib.script.dom.BreakAfter = xfalib.script.DOMElement.extend({
        msClassName:"breakAfter"
    });

    BreakAfter.defineProps({
        leader:{
            get:function () {
                return this.getAttribute("leader");
            },
            set:function (value) {
                this.setAttribute(value, "leader");
            }
        },
        startNew:{
            get:function () {
                return this.getAttribute("startNew");
            },
            set:function (value) {
                this.setAttribute(value, "startNew");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        targetType:{
            get:function () {
                return this.getAttribute("targetType");
            },
            set:function (value) {
                this.setAttribute(value, "targetType");
            }
        },
        trailer:{
            get:function () {
                return this.getAttribute("trailer");
            },
            set:function (value) {
                this.setAttribute(value, "trailer");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var BreakBefore = xfalib.script.dom.BreakBefore = xfalib.script.DOMElement.extend({
        msClassName:"breakBefore"
    });

    BreakBefore.defineProps({
        leader:{
            get:function () {
                return this.getAttribute("leader");
            },
            set:function (value) {
                this.setAttribute(value, "leader");
            }
        },
        startNew:{
            get:function () {
                return this.getAttribute("startNew");
            },
            set:function (value) {
                this.setAttribute(value, "startNew");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        targetType:{
            get:function () {
                return this.getAttribute("targetType");
            },
            set:function (value) {
                this.setAttribute(value, "targetType");
            }
        },
        trailer:{
            get:function () {
                return this.getAttribute("trailer");
            },
            set:function (value) {
                this.setAttribute(value, "trailer");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Button = xfalib.script.dom.Button = xfalib.script.DOMElement.extend({
        msClassName:"button"
    });

    Button.defineProps({
        highlight:{
            get:function () {
                return this.getAttribute("highlight");
            },
            set:function (value) {
                this.setAttribute(value, "highlight");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Calculate = xfalib.script.dom.Calculate = xfalib.script.DOMElement.extend({
        msClassName:"calculate"
    });

    Calculate.defineProps({
        override:{
            get:function () {
                return this.getAttribute("override");
            },
            set:function (value) {
                this.setAttribute(value, "override");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        message:{
            get:function () {
                return this.getElement("message", 0);
            },
            set:function (value) {
                this.setElement(value, "message");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Caption = xfalib.script.dom.Caption = xfalib.script.DOMElement.extend({
        msClassName:"caption"
    });

    Caption.defineProps({
        placement:{
            get:function () {
                return this.getAttribute("placement");
            },
            set:function (value) {
                this.setAttribute(value, "placement");
            }
        },
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
            }
        },
        reserve:{
            get:function () {
                return this.getAttribute("reserve");
            },
            set:function (value) {
                this.setAttribute(value, "reserve");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        font:{
            get:function () {
                return this.getElement("font", 0);
            },
            set:function (value) {
                this.setElement(value, "font");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        },
        para:{
            get:function () {
                return this.getElement("para", 0);
            },
            set:function (value) {
                this.setElement(value, "para");
            }
        },
        value:{
            get:function () {
                return this.getElement("value", 0);
            },
            set:function (value) {
                this.setElement(value, "value");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Certificate = xfalib.script.dom.Certificate = xfalib.script.GenericText.extend({
        msClassName:"certificate"
    });

    Certificate.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var Certificates = xfalib.script.dom.Certificates = xfalib.script.DOMElement.extend({
        msClassName:"certificates"
    });

    Certificates.defineProps({
        credentialServerPolicy:{
            get:function () {
                return this.getAttribute("credentialServerPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "credentialServerPolicy");
            }
        },
        url:{
            get:function () {
                return this.getAttribute("url");
            },
            set:function (value) {
                this.setAttribute(value, "url");
            }
        },
        urlPolicy:{
            get:function () {
                return this.getAttribute("urlPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "urlPolicy");
            }
        },
        encryption:{
            get:function () {
                return this.getElement("encryption", 0);
            },
            set:function (value) {
                this.setElement(value, "encryption");
            }
        },
        issuers:{
            get:function () {
                return this.getElement("issuers", 0);
            },
            set:function (value) {
                this.setElement(value, "issuers");
            }
        },
        keyUsage:{
            get:function () {
                return this.getElement("keyUsage", 0);
            },
            set:function (value) {
                this.setElement(value, "keyUsage");
            }
        },
        oids:{
            get:function () {
                return this.getElement("oids", 0);
            },
            set:function (value) {
                this.setElement(value, "oids");
            }
        },
        signing:{
            get:function () {
                return this.getElement("signing", 0);
            },
            set:function (value) {
                this.setElement(value, "signing");
            }
        },
        subjectDNs:{
            get:function () {
                return this.getElement("subjectDNs", 0);
            },
            set:function (value) {
                this.setElement(value, "subjectDNs");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var CheckButton = xfalib.script.dom.CheckButton = xfalib.script.DOMElement.extend({
        msClassName:"checkButton"
    });

    CheckButton.defineProps({
        allowNeutral:{
            get:function () {
                return this.getAttribute("allowNeutral");
            },
            set:function (value) {
                this.setAttribute(value, "allowNeutral");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,this,"allowNeutral",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        mark:{
            get:function () {
                return this.getAttribute("mark");
            },
            set:function (value) {
                this.setAttribute(value, "mark");
            }
        },
        shape:{
            get:function () {
                return this.getAttribute("shape");
            },
            set:function (value) {
                this.setAttribute(value, "shape");
            }
        },
        size:{
            get:function () {
                return this.getAttribute("size");
            },
            set:function (value) {
                this.setAttribute(value, "size");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var ChoiceList = xfalib.script.dom.ChoiceList = xfalib.script.DOMElement.extend({
        msClassName:"choiceList"
    });

    ChoiceList.defineProps({
        commitOn:{
            get:function () {
                return this.getAttribute("commitOn");
            },
            set:function (value) {
                this.setAttribute(value, "commitOn");
            }
        },
        open:{
            get:function () {
                return this.getAttribute("open");
            },
            set:function (value) {
                this.setAttribute(value, "open");
            }
        },
        textEntry:{
            get:function () {
                return this.getAttribute("textEntry");
            },
            set:function (value) {
                this.setAttribute(value, "textEntry");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Color = xfalib.script.dom.Color = xfalib.script.DOMElement.extend({
        msClassName:"color"
    });

    Color.defineProps({
        cSpace:{
            get:function () {
                return this.getAttribute("cSpace");
            },
            set:function (value) {
                this.setAttribute(value, "cSpace");
            }
        },
        value:{
            get:function () {
                return this.getAttribute("value");
            },
            set:function (value) {
                this.setAttribute(value, "value");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"color.value",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Comb = xfalib.script.dom.Comb = xfalib.script.GenericText.extend({
        msClassName:"comb"
    });

    Comb.defineProps({
        numberOfCells:{
            get:function () {
                return this.getAttribute("numberOfCells");
            },
            set:function (value) {
                this.setAttribute(value, "numberOfCells");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Connect = xfalib.script.dom.Connect = xfalib.script.DOMElement.extend({
        msClassName:"connect"
    });

    Connect.defineProps({
        connection:{
            get:function () {
                return this.getAttribute("connection");
            },
            set:function (value) {
                this.setAttribute(value, "connection");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        usage:{
            get:function () {
                return this.getAttribute("usage");
            },
            set:function (value) {
                this.setAttribute(value, "usage");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Corner = xfalib.script.dom.Corner = xfalib.script.DOMElement.extend({
        msClassName:"corner"
    });

    Corner.defineProps({
        inverted:{
            get:function () {
                return this.getAttribute("inverted");
            },
            set:function (value) {
                this.setAttribute(value, "inverted");
            }
        },
        join:{
            get:function () {
                return this.getAttribute("join");
            },
            set:function (value) {
                this.setAttribute(value, "join");
            }
        },
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
            }
        },
        radius:{
            get:function () {
                return this.getAttribute("radius");
            },
            set:function (value) {
                this.setAttribute(value, "radius");
            }
        },
        stroke:{
            get:function () {
                return this.getAttribute("stroke");
            },
            set:function (value) {
                this.setAttribute(value, "stroke");
            }
        },
        thickness:{
            get:function () {
                return this.getAttribute("thickness");
            },
            set:function (value) {
                this.setAttribute(value, "thickness");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var DateTimeEdit = xfalib.script.dom.DateTimeEdit = xfalib.script.DOMElement.extend({
        msClassName:"dateTimeEdit"
    });

    DateTimeEdit.defineProps({
        hScrollPolicy:{
            get:function () {
                return this.getAttribute("hScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "hScrollPolicy");
            }
        },
        picker:{
            get:function () {
                return this.getAttribute("picker");
            },
            set:function (value) {
                this.setAttribute(value, "picker");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        comb:{
            get:function () {
                return this.getElement("comb", 0);
            },
            set:function (value) {
                this.setElement(value, "comb");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var DefaultUi = xfalib.script.dom.DefaultUi = xfalib.script.DOMElement.extend({
        msClassName:"defaultUi"
    });

    DefaultUi.defineProps({
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function(_,xfalib){
    var Desc = xfalib.script.dom.Desc = xfalib.script.DOMElement.extend({
        msClassName: "desc"
    });

})(_,xfalib);
(function (_, xfalib) {
    var DigestMethod = xfalib.script.dom.DigestMethod = xfalib.script.GenericText.extend({
        msClassName:"digestMethod"
    });

    DigestMethod.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var DigestMethods = xfalib.script.dom.DigestMethods = xfalib.script.DOMElement.extend({
        msClassName:"digestMethods"
    });

    DigestMethods.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Edge = xfalib.script.dom.Edge = xfalib.script.DOMElement.extend({
        msClassName:"edge"
    });

    Edge.defineProps({
        cap:{
            get:function () {
                return this.getAttribute("cap");
            },
            set:function (value) {
                this.setAttribute(value, "cap");
            }
        },
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"edge.presence",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        stroke:{
            get:function () {
                return this.getAttribute("stroke");
            },
            set:function (value) {
                this.setAttribute(value, "stroke");
            }
        },
        thickness:{
            get:function () {
                return this.getAttribute("thickness");
            },
            set:function (value) {
                this.setAttribute(value, "thickness");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"edge.thickness",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Encoding = xfalib.script.dom.Encoding = xfalib.script.GenericText.extend({
        msClassName:"encoding"
    });

    Encoding.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var Encodings = xfalib.script.dom.Encodings = xfalib.script.DOMElement.extend({
        msClassName:"encodings"
    });

    Encodings.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Encrypt = xfalib.script.dom.Encrypt = xfalib.script.DOMElement.extend({
        msClassName:"encrypt"
    });

    Encrypt.defineProps({
        certificate:{
            get:function () {
                return this.getElement("certificate", 0);
            },
            set:function (value) {
                this.setElement(value, "certificate");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var EncryptData = xfalib.script.dom.EncryptData = xfalib.script.DOMElement.extend({
        msClassName:"encryptData"
    });

    EncryptData.defineProps({
        operation:{
            get:function () {
                return this.getAttribute("operation");
            },
            set:function (value) {
                this.setAttribute(value, "operation");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        filter:{
            get:function () {
                return this.getElement("filter", 0);
            },
            set:function (value) {
                this.setElement(value, "filter");
            }
        },
        manifest:{
            get:function () {
                return this.getElement("manifest", 0);
            },
            set:function (value) {
                this.setElement(value, "manifest");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Encryption = xfalib.script.dom.Encryption = xfalib.script.DOMElement.extend({
        msClassName:"encryption"
    });

    Encryption.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var EncryptionMethod = xfalib.script.dom.EncryptionMethod = xfalib.script.GenericText.extend({
        msClassName:"encryptionMethod"
    });

})(_, xfalib);
(function (_, xfalib) {
    var EncryptionMethods = xfalib.script.dom.EncryptionMethods = xfalib.script.DOMElement.extend({
        msClassName:"encryptionMethods"
    });

    EncryptionMethods.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Event = xfalib.script.dom.Event = xfalib.script.DOMElement.extend({
        msClassName:"event"
    });

    Event.defineProps({
        activity:{
            get:function () {
                return this.getAttribute("activity");
            },
            set:function (value) {
                this.setAttribute(value, "activity");
            }
        },
        listen:{
            get:function () {
                return this.getAttribute("listen");
            },
            set:function (value) {
                this.setAttribute(value, "listen");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        encryptData:{
            get:function () {
                return this.getElement("encryptData", 0);
            },
            set:function (value) {
                this.setElement(value, "encryptData");
            }
        },
        execute:{
            get:function () {
                return this.getElement("execute", 0);
            },
            set:function (value) {
                this.setElement(value, "execute");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        },
        signData:{
            get:function () {
                return this.getElement("signData", 0);
            },
            set:function (value) {
                this.setElement(value, "signData");
            }
        },
        submit:{
            get:function () {
                return this.getElement("submit", 0);
            },
            set:function (value) {
                this.setElement(value, "submit");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Execute = xfalib.script.dom.Execute = xfalib.script.GenericText.extend({
        msClassName:"execute"
    });

    Execute.defineProps({
        connection:{
            get:function () {
                return this.getAttribute("connection");
            },
            set:function (value) {
                this.setAttribute(value, "connection");
            }
        },
        executeType:{
            get:function () {
                return this.getAttribute("executeType");
            },
            set:function (value) {
                this.setAttribute(value, "executeType");
            }
        },
        runAt:{
            get:function () {
                return this.getAttribute("runAt");
            },
            set:function (value) {
                this.setAttribute(value, "runAt");
            }
        }
    });

})(_, xfalib);
(function(_,xfalib){
    var Extras = xfalib.script.dom.Extras = xfalib.script.DOMElement.extend({
        msClassName: "extras"
    });

})(_,xfalib);
(function (_, xfalib) {
    var Fill = xfalib.script.dom.Fill = xfalib.script.DOMElement.extend({
        msClassName:"fill"
    });

    Fill.defineProps({
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"fill.presence",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        linear:{
            get:function () {
                return this.getElement("linear", 0);
            },
            set:function (value) {
                this.setElement(value, "linear");
            }
        },
        pattern:{
            get:function () {
                return this.getElement("pattern", 0);
            },
            set:function (value) {
                this.setElement(value, "pattern");
            }
        },
        radial:{
            get:function () {
                return this.getElement("radial", 0);
            },
            set:function (value) {
                this.setElement(value, "radial");
            }
        },
        solid:{
            get:function () {
                return this.getElement("solid", 0);
            },
            set:function (value) {
                this.setElement(value, "solid");
            }
        },
        stipple:{
            get:function () {
                return this.getElement("stipple", 0);
            },
            set:function (value) {
                this.setElement(value, "stipple");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Filter = xfalib.script.dom.Filter = xfalib.script.DOMElement.extend({
        msClassName:"filter"
    });

    Filter.defineProps({
        addRevocationInfo:{
            get:function () {
                return this.getAttribute("addRevocationInfo");
            },
            set:function (value) {
                this.setAttribute(value, "addRevocationInfo");
            }
        },
        version:{
            get:function () {
                return this.getAttribute("version");
            },
            set:function (value) {
                this.setAttribute(value, "version");
            }
        },
        appearanceFilter:{
            get:function () {
                return this.getElement("appearanceFilter", 0);
            },
            set:function (value) {
                this.setElement(value, "appearanceFilter");
            }
        },
        certificates:{
            get:function () {
                return this.getElement("certificates", 0);
            },
            set:function (value) {
                this.setElement(value, "certificates");
            }
        },
        digestMethods:{
            get:function () {
                return this.getElement("digestMethods", 0);
            },
            set:function (value) {
                this.setElement(value, "digestMethods");
            }
        },
        encodings:{
            get:function () {
                return this.getElement("encodings", 0);
            },
            set:function (value) {
                this.setElement(value, "encodings");
            }
        },
        encryptionMethods:{
            get:function () {
                return this.getElement("encryptionMethods", 0);
            },
            set:function (value) {
                this.setElement(value, "encryptionMethods");
            }
        },
        handler:{
            get:function () {
                return this.getElement("handler", 0);
            },
            set:function (value) {
                this.setElement(value, "handler");
            }
        },
        lockDocument:{
            get:function () {
                return this.getElement("lockDocument", 0);
            },
            set:function (value) {
                this.setElement(value, "lockDocument");
            }
        },
        mdp:{
            get:function () {
                return this.getElement("mdp", 0);
            },
            set:function (value) {
                this.setElement(value, "mdp");
            }
        },
        reasons:{
            get:function () {
                return this.getElement("reasons", 0);
            },
            set:function (value) {
                this.setElement(value, "reasons");
            }
        },
        timeStamp:{
            get:function () {
                return this.getElement("timeStamp", 0);
            },
            set:function (value) {
                this.setElement(value, "timeStamp");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Font = xfalib.script.dom.Font = xfalib.script.DOMElement.extend({
        msClassName:"font"
    });

    Font.defineProps({
        baselineShift:{
            get:function () {
                return this.getAttribute("baselineShift");
            },
            set:function (value) {
                this.setAttribute(value, "baselineShift");
            }
        },
        fontHorizontalScale:{
            get:function () {
                return this.getAttribute("fontHorizontalScale");
            },
            set:function (value) {
                this.setAttribute(value, "fontHorizontalScale");
            }
        },
        fontVerticalScale:{
            get:function () {
                return this.getAttribute("fontVerticalScale");
            },
            set:function (value) {
                this.setAttribute(value, "fontVerticalScale");
            }
        },
        kerningMode:{
            get:function () {
                return this.getAttribute("kerningMode");
            },
            set:function (value) {
                this.setAttribute(value, "kerningMode");
            }
        },
        letterSpacing:{
            get:function () {
                return this.getAttribute("letterSpacing");
            },
            set:function (value) {
                this.setAttribute(value, "letterSpacing");
            }
        },
        lineThrough:{
            get:function () {
                return this.getAttribute("lineThrough");
            },
            set:function (value) {
                this.setAttribute(value, "lineThrough");
            }
        },
        lineThroughPeriod:{
            get:function () {
                return this.getAttribute("lineThroughPeriod");
            },
            set:function (value) {
                this.setAttribute(value, "lineThroughPeriod");
            }
        },
        overline:{
            get:function () {
                return this.getAttribute("overline");
            },
            set:function (value) {
                this.setAttribute(value, "overline");
            }
        },
        overlinePeriod:{
            get:function () {
                return this.getAttribute("overlinePeriod");
            },
            set:function (value) {
                this.setAttribute(value, "overlinePeriod");
            }
        },
        posture:{
            get:function () {
                return this.getAttribute("posture");
            },
            set:function (value) {
                this.setAttribute(value, "posture");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this, "font.posture", value, null);
                this.trigger(evnt.name, evnt);
            }
        },
        size:{
            get:function () {
                return this.getAttribute("size");
            },
            set:function (value) {
                this.setAttribute(value, "size");
            }
        },
        typeface:{
            get:function () {
                return this.getAttribute("typeface");
            },
            set:function (value) {
                this.setAttribute(value, "typeface");
            }
        },
        underline:{
            get:function () {
                return this.getAttribute("underline");
            },
            set:function (value) {
                this.setAttribute(value, "underline");
            }
        },
        underlinePeriod:{
            get:function () {
                return this.getAttribute("underlinePeriod");
            },
            set:function (value) {
                this.setAttribute(value, "underlinePeriod");
            }
        },
        weight:{
            get:function () {
                return this.getAttribute("weight");
            },
            set:function (value) {
                this.setAttribute(value, "weight");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        fill:{
            get:function () {
                return this.getElement("fill", 0);
            },
            set:function (value) {
                this.setElement(value, "fill");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Format = xfalib.script.dom.Format = xfalib.script.DOMElement.extend({
        msClassName:"format"
    });

    Format.defineProps({
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Handler = xfalib.script.dom.Handler = xfalib.script.GenericText.extend({
        msClassName:"handler"
    });

    Handler.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Hyphenation = xfalib.script.dom.Hyphenation = xfalib.script.GenericText.extend({
        msClassName:"hyphenation"
    });

    Hyphenation.defineProps({
        excludeAllCaps:{
            get:function () {
                return this.getAttribute("excludeAllCaps");
            },
            set:function (value) {
                this.setAttribute(value, "excludeAllCaps");
            }
        },
        excludeInitialCap:{
            get:function () {
                return this.getAttribute("excludeInitialCap");
            },
            set:function (value) {
                this.setAttribute(value, "excludeInitialCap");
            }
        },
        hyphenate:{
            get:function () {
                return this.getAttribute("hyphenate");
            },
            set:function (value) {
                this.setAttribute(value, "hyphenate");
            }
        },
        ladderCount:{
            get:function () {
                return this.getAttribute("ladderCount");
            },
            set:function (value) {
                this.setAttribute(value, "ladderCount");
            }
        },
        pushCharacterCount:{
            get:function () {
                return this.getAttribute("pushCharacterCount");
            },
            set:function (value) {
                this.setAttribute(value, "pushCharacterCount");
            }
        },
        remainCharacterCount:{
            get:function () {
                return this.getAttribute("remainCharacterCount");
            },
            set:function (value) {
                this.setAttribute(value, "remainCharacterCount");
            }
        },
        wordCharacterCount:{
            get:function () {
                return this.getAttribute("wordCharacterCount");
            },
            set:function (value) {
                this.setAttribute(value, "wordCharacterCount");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var ImageEdit = xfalib.script.dom.ImageEdit = xfalib.script.DOMElement.extend({
        msClassName:"imageEdit"
    });

    ImageEdit.defineProps({
        data:{
            get:function () {
                return this.getAttribute("data");
            },
            set:function (value) {
                this.setAttribute(value, "data");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Issuers = xfalib.script.dom.Issuers = xfalib.script.DOMElement.extend({
        msClassName:"issuers"
    });

    Issuers.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Items = xfalib.script.dom.Items = xfalib.script.DOMElement.extend({
        _defaults: {
            "save": "0"
        },

        msClassName: "items",
        initialize: function () {
            Items._super.initialize.call(this);
        },

        _computeJsonDiff: function (diff_level) {

            /*
             * always return <items> - bug#3621898
             * In case of final submission, don't send Items
             */
            return diff_level === 2 ? {
                "changed": false,
                jsonDifference: {}
            } : {
                "changed": true,
                jsonDifference: this.jsonModel
            };
        }

    });

    Items.defineProps({
        "save": {
            get: function () {
                return this.getAttribute("save");
            }
        }
    });

    Items.addMixins([
        xfalib.script.mixin.AddPresence
    ]);
})(_, xfalib);

(function (_, xfalib) {
    var Keep = xfalib.script.dom.Keep = xfalib.script.DOMElement.extend({
        msClassName:"keep"
    });

    Keep.defineProps({
        intact:{
            get:function () {
                return this.getAttribute("intact");
            },
            set:function (value) {
                this.setAttribute(value, "intact");
            }
        },
        next:{
            get:function () {
                return this.getAttribute("next");
            },
            set:function (value) {
                this.setAttribute(value, "next");
            }
        },
        previous:{
            get:function () {
                return this.getAttribute("previous");
            },
            set:function (value) {
                this.setAttribute(value, "previous");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var KeyUsage = xfalib.script.dom.KeyUsage = xfalib.script.GenericText.extend({
        msClassName:"keyUsage"
    });

    KeyUsage.defineProps({
        crlSign:{
            get:function () {
                return this.getAttribute("crlSign");
            },
            set:function (value) {
                this.setAttribute(value, "crlSign");
            }
        },
        dataEncipherment:{
            get:function () {
                return this.getAttribute("dataEncipherment");
            },
            set:function (value) {
                this.setAttribute(value, "dataEncipherment");
            }
        },
        decipherOnly:{
            get:function () {
                return this.getAttribute("decipherOnly");
            },
            set:function (value) {
                this.setAttribute(value, "decipherOnly");
            }
        },
        digitalSignature:{
            get:function () {
                return this.getAttribute("digitalSignature");
            },
            set:function (value) {
                this.setAttribute(value, "digitalSignature");
            }
        },
        encipherOnly:{
            get:function () {
                return this.getAttribute("encipherOnly");
            },
            set:function (value) {
                this.setAttribute(value, "encipherOnly");
            }
        },
        keyAgreement:{
            get:function () {
                return this.getAttribute("keyAgreement");
            },
            set:function (value) {
                this.setAttribute(value, "keyAgreement");
            }
        },
        keyCertSign:{
            get:function () {
                return this.getAttribute("keyCertSign");
            },
            set:function (value) {
                this.setAttribute(value, "keyCertSign");
            }
        },
        keyEncipherment:{
            get:function () {
                return this.getAttribute("keyEncipherment");
            },
            set:function (value) {
                this.setAttribute(value, "keyEncipherment");
            }
        },
        nonRepudiation:{
            get:function () {
                return this.getAttribute("nonRepudiation");
            },
            set:function (value) {
                this.setAttribute(value, "nonRepudiation");
            }
        },
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Linear = xfalib.script.dom.Linear = xfalib.script.DOMElement.extend({
        msClassName:"linear"
    });

    Linear.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var LockDocument = xfalib.script.dom.LockDocument = xfalib.script.GenericText.extend({
        msClassName:"lockDocument"
    });

    LockDocument.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Manifest = xfalib.script.dom.Manifest = xfalib.script.DOMElement.extend({
        msClassName:"manifest"
    });

    Manifest.defineProps({
        action:{
            get:function () {
                return this.getAttribute("action");
            },
            set:function (value) {
                this.setAttribute(value, "action");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Margin = xfalib.script.dom.Margin = xfalib.script.DOMElement.extend({
        msClassName:"margin"
    });

    Margin.defineProps({
        bottomInset:{
            get:function () {
                return this.getAttribute("bottomInset");
            },
            set:function (value) {
                this.setAttribute(value, "bottomInset");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"bottomInset",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        leftInset:{
            get:function () {
                return this.getAttribute("leftInset");
            },
            set:function (value) {
                this.setAttribute(value, "leftInset");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"leftInset",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        rightInset:{
            get:function () {
                return this.getAttribute("rightInset");
            },
            set:function (value) {
                this.setAttribute(value, "rightInset");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"rightInset",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        topInset:{
            get:function () {
                return this.getAttribute("topInset");
            },
            set:function (value) {
                this.setAttribute(value, "topInset");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"topInset",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Mdp = xfalib.script.dom.Mdp = xfalib.script.GenericText.extend({
        msClassName:"mdp"
    });

    Mdp.defineProps({
        permissions:{
            get:function () {
                return this.getAttribute("permissions");
            },
            set:function (value) {
                this.setAttribute(value, "permissions");
            }
        },
        signatureType:{
            get:function () {
                return this.getAttribute("signatureType");
            },
            set:function (value) {
                this.setAttribute(value, "signatureType");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Medium = xfalib.script.dom.Medium = xfalib.script.GenericText.extend({
        msClassName:"medium"
    });

    Medium.defineProps({
        imagingBBox:{
            get:function () {
                return this.getAttribute("imagingBBox");
            },
            set:function (value) {
                this.setAttribute(value, "imagingBBox");
            }
        },
        "long":{
            get:function () {
                return this.getAttribute("long");
            },
            set:function (value) {
                this.setAttribute(value, "long");
            }
        },
        orientation:{
            get:function () {
                return this.getAttribute("orientation");
            },
            set:function (value) {
                this.setAttribute(value, "orientation");
            }
        },
        "short":{
            get:function () {
                return this.getAttribute("short");
            },
            set:function (value) {
                this.setAttribute(value, "short");
            }
        },
        stock:{
            get:function () {
                return this.getAttribute("stock");
            },
            set:function (value) {
                this.setAttribute(value, "stock");
            }
        },
        trayIn:{
            get:function () {
                return this.getAttribute("trayIn");
            },
            set:function (value) {
                this.setAttribute(value, "trayIn");
            }
        },
        trayOut:{
            get:function () {
                return this.getAttribute("trayOut");
            },
            set:function (value) {
                this.setAttribute(value, "trayOut");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Message = xfalib.script.dom.Message = xfalib.script.DOMElement.extend({
        msClassName:"message"
    });

})(_, xfalib);
(function (_, xfalib) {
    var NumericEdit = xfalib.script.dom.NumericEdit = xfalib.script.DOMElement.extend({
        msClassName:"numericEdit"
    });

    NumericEdit.defineProps({
        hScrollPolicy:{
            get:function () {
                return this.getAttribute("hScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "hScrollPolicy");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        comb:{
            get:function () {
                return this.getElement("comb", 0);
            },
            set:function (value) {
                this.setElement(value, "comb");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Occur = xfalib.script.dom.Occur = xfalib.script.DOMElement.extend({
        msClassName:"occur",
        playJson : function(pJsonModel) {

        }

    });

    Occur.defineProps({
        initial:{
            get:function () {
                return this.getAttribute("initial");
            },
            set:function (value) {
                this.setAttribute(value, "initial");
            }
        },
        max:{
            get:function () {
                return this.getAttribute("max");
            },
            set:function (value) {
                this.setAttribute(value, "max");
            }
        },
        min:{
            get:function () {
                return this.getAttribute("min");
            },
            set:function (value) {
                this.setAttribute(value, "min");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Oid = xfalib.script.dom.Oid = xfalib.script.GenericText.extend({
        msClassName:"oid"
    });

})(_, xfalib);
(function (_, xfalib) {
    var Oids = xfalib.script.dom.Oids = xfalib.script.DOMElement.extend({
        msClassName:"oids"
    });

    Oids.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Overflow = xfalib.script.dom.Overflow = xfalib.script.GenericText.extend({
        msClassName:"overflow"
    });

    Overflow.defineProps({
        leader:{
            get:function () {
                return this.getAttribute("leader");
            },
            set:function (value) {
                this.setAttribute(value, "leader");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        trailer:{
            get:function () {
                return this.getAttribute("trailer");
            },
            set:function (value) {
                this.setAttribute(value, "trailer");
            }
        }
    });

})(_, xfalib);
(function(_,xfalib){
    var Para = xfalib.script.dom.Para = xfalib.script.DOMElement.extend({
        msClassName:"para"
    });

    Para.defineProps({
        hAlign : {
            get : function(){
                return this.getAttribute("hAlign");
            },
            set : function(value){
                this.setAttribute(value, "hAlign");
            }
        },

        lineHeight : {
            get : function(){
                return this.getAttribute("lineHeight");
            },
            set : function(value){
                this.setAttribute(value, "lineHeight");
            }
        },

        marginLeft : {
            get : function(){
                return this.getAttribute("marginLeft");
            },
            set : function(value){
                this.setAttribute(value, "marginLeft");
            }
        },

        marginRight : {
            get : function(){
                return this.getAttribute("marginRight");
            },
            set : function(value){
                this.setAttribute(value, "marginRight");
            }
        },

        orphans : {
            get : function(){
                return this.getAttribute("orphans");
            },
            set : function(value){
                this.setAttribute(value, "orphans");
            }
        },

        preserve : {
            get : function(){
                return this.getAttribute("preserve");
            },
            set : function(value){
                this.setAttribute(value, "preserve");
            }
        },

        radixOffset : {
            get : function(){
                return this.getAttribute("radixOffset");
            },
            set : function(value){
                this.setAttribute(value, "radixOffset");
            }
        },

        spaceAbove : {
            get : function(){
                return this.getAttribute("spaceAbove");
            },
            set : function(value){
                this.setAttribute(value, "spaceAbove");
            }
        },

        spaceBelow : {
            get : function(){
                return this.getAttribute("spaceBelow");
            },
            set : function(value){
                this.setAttribute(value, "spaceBelow");
            }
        },

        tabDefault : {
            get : function(){
                return this.getAttribute("tabDefault");
            },
            set : function(value){
                this.setAttribute(value, "tabDefault");
            }
        },

        tabStops : {
            get : function(){
                return this.getAttribute("tabStops");
            },
            set : function(value){
                this.setAttribute(value, "tabStops");
            }
        },

        textIndent : {
            get : function(){
                return this.getAttribute("textIndent");
            },
            set : function(value){
                this.setAttribute(value, "textIndent");
            }
        },

        vAlign : {
            get : function(){
                return this.getAttribute("vAlign");
            },
            set : function(value){
                this.setAttribute(value, "vAlign");
            }
        },

        widows : {
            get : function(){
                return this.getAttribute("widows");
            },
            set : function(value){
                this.setAttribute(value, "widows");
            }
        },

        wordSpacingMaximum : {
            get : function(){
                return this.getAttribute("wordSpacingMaximum");
            },
            set : function(value){
                this.setAttribute(value, "wordSpacingMaximum");
            }
        },

        wordSpacingMinimum : {
            get : function(){
                return this.getAttribute("wordSpacingMinimum");
            },
            set : function(value){
                this.setAttribute(value, "wordSpacingMinimum");
            }
        },

        wordSpacingOptimum : {
            get : function(){
                return this.getAttribute("wordSpacingOptimum");
            },
            set : function(value){
                this.setAttribute(value, "wordSpacingOptimum");
            }
        }
    });

})(_,xfalib);


(function (_, xfalib) {
    var PasswordEdit = xfalib.script.dom.PasswordEdit = xfalib.script.DOMElement.extend({
        msClassName:"passwordEdit"
    });

    PasswordEdit.defineProps({
        hScrollPolicy:{
            get:function () {
                return this.getAttribute("hScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "hScrollPolicy");
            }
        },
        passwordChar:{
            get:function () {
                return this.getAttribute("passwordChar");
            },
            set:function (value) {
                this.setAttribute(value, "passwordChar");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Pattern = xfalib.script.dom.Pattern = xfalib.script.DOMElement.extend({
        msClassName:"pattern"
    });

    Pattern.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Picture = xfalib.script.dom.Picture = xfalib.script.GenericText.extend({
        msClassName:"picture"
    });

    Picture.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var Radial = xfalib.script.dom.Radial = xfalib.script.DOMElement.extend({
        msClassName:"radial"
    });

    Radial.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Reason = xfalib.script.dom.Reason = xfalib.script.GenericText.extend({
        msClassName:"reason"
    });

})(_, xfalib);
(function (_, xfalib) {
    var Reasons = xfalib.script.dom.Reasons = xfalib.script.DOMElement.extend({
        msClassName:"reasons"
    });

    Reasons.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Ref = xfalib.script.dom.Ref = xfalib.script.GenericText.extend({
        msClassName:"ref"
    });

    Ref.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var RenderAs = xfalib.script.dom.RenderAs = xfalib.script.DOMElement.extend({
        msClassName:"renderAs"
    });

    RenderAs.defineProps({
        APIVersion:{
            get:function () {
                return this.getAttribute("APIVersion");
            },
            set:function (value) {
                this.setAttribute(value, "APIVersion");
            }
        },
        svg:{
            get:function () {
                return this.getElement("svg", 0);
            },
            set:function (value) {
                this.setElement(value, "svg");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Script = xfalib.script.dom.Script = xfalib.script.GenericText.extend({
        msClassName:"script"
    });

    Script.defineProps({
        binding:{
            get:function () {
                return this.getAttribute("binding");
            },
            set:function (value) {
                this.setAttribute(value, "binding");
            }
        },
        contentType:{
            get:function () {
                return this.getAttribute("contentType");
            },
            set:function (value) {
                this.setAttribute(value, "contentType");
            }
        },
        runAt:{
            get:function () {
                return this.getAttribute("runAt");
            },
            set:function (value) {
                this.setAttribute(value, "runAt");
            }
        },
        stateless:{
            get:function () {
                return this.getAttribute("stateless");
            },
            set:function (value) {
                this.setAttribute(value, "stateless");
            }
        }
    });

})(_, xfalib);
(function(_, xfalib){
    var ScriptObject = xfalib.script.dom.ScriptObject = xfalib.script.dom.Script.extend({
        msClassName: "script",
        initialize : function(){
            ScriptObject._super.initialize.call(this);
            this._scriptInitialized = false;
        },

        _getNakedThis : function(){
            if(!this._scriptInitialized){
                if(this.value){
                    try{
                        var oldScope = null;
                        if(this.parent.parent instanceof xfalib.script.EventContainerNode) {
                            oldScope = this.parent.parent._createNakedReferencesScope();
                        }
                        this._xfa()._pushContextNode(this);
                        with(this.parent.parent) { // the parent subform of script obj.
                            with(xfalib.runtime) {
                                //TODO: possible xss attack
                                (eval("("+this.value+")")).apply(this.parent.parent,[this]); // subform -> self, this -> baseobj / script Obj
                            }
                        }
                    } catch(exception){
                        var som = this._xfa().moContextNodes[0] ? this._xfa().moContextNodes[0].somExpression
                                                                : ""
                        this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-015"],
                                                [exception.message, this.name,
                                                 this._xfa().event.name, som])
                    } finally {
                        if(oldScope != null) {
                            this.parent.parent._resetNakedReferencesScope(oldScope);
                        }
                        this._xfa()._popContextNode();
                    }
                }
                this._scriptInitialized = true;
            }
            return this;
        }

    });
})(_, xfalib);
(function (_, xfalib) {
    var SetProperty = xfalib.script.dom.SetProperty = xfalib.script.GenericText.extend({
        msClassName:"setProperty"
    });

    SetProperty.defineProps({
        connection:{
            get:function () {
                return this.getAttribute("connection");
            },
            set:function (value) {
                this.setAttribute(value, "connection");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Signature = xfalib.script.dom.Signature = xfalib.script.DOMElement.extend({
        msClassName:"signature"
    });

    Signature.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        filter:{
            get:function () {
                return this.getElement("filter", 0);
            },
            set:function (value) {
                this.setElement(value, "filter");
            }
        },
        manifest:{
            get:function () {
                return this.getElement("manifest", 0);
            },
            set:function (value) {
                this.setElement(value, "manifest");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var SignData = xfalib.script.dom.SignData = xfalib.script.DOMElement.extend({
        msClassName:"signData"
    });

    SignData.defineProps({
        operation:{
            get:function () {
                return this.getAttribute("operation");
            },
            set:function (value) {
                this.setAttribute(value, "operation");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        filter:{
            get:function () {
                return this.getElement("filter", 0);
            },
            set:function (value) {
                this.setElement(value, "filter");
            }
        },
        manifest:{
            get:function () {
                return this.getElement("manifest", 0);
            },
            set:function (value) {
                this.setElement(value, "manifest");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Signing = xfalib.script.dom.Signing = xfalib.script.DOMElement.extend({
        msClassName:"signing"
    });

    Signing.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Solid = xfalib.script.dom.Solid = xfalib.script.DOMElement.extend({
        msClassName:"solid"
    });

    Solid.defineProps({
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Speak = xfalib.script.dom.Speak = xfalib.script.GenericText.extend({
        msClassName:"speak"
    });

    Speak.defineProps({
        disable:{
            get:function () {
                return this.getAttribute("disable");
            },
            set:function (value) {
                this.setAttribute(value, "disable");
            }
        },
        priority:{
            get:function () {
                return this.getAttribute("priority");
            },
            set:function (value) {
                this.setAttribute(value, "priority");
            }
        },
        rid:{
            get:function () {
                return this.getAttribute("rid");
            },
            set:function (value) {
                this.setAttribute(value, "rid");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Stipple = xfalib.script.dom.Stipple = xfalib.script.DOMElement.extend({
        msClassName:"stipple"
    });

    Stipple.defineProps({
        rate:{
            get:function () {
                return this.getAttribute("rate");
            },
            set:function (value) {
                this.setAttribute(value, "rate");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var SubjectDN = xfalib.script.dom.SubjectDN = xfalib.script.GenericText.extend({
        msClassName:"subjectDN"
    });

    SubjectDN.defineProps({
        delimiter:{
            get:function () {
                return this.getAttribute("delimiter");
            },
            set:function (value) {
                this.setAttribute(value, "delimiter");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var SubjectDNs = xfalib.script.dom.SubjectDNs = xfalib.script.DOMElement.extend({
        msClassName:"subjectDNs"
    });

    SubjectDNs.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Submit = xfalib.script.dom.Submit = xfalib.script.DOMElement.extend({
        msClassName:"submit"
    });

    Submit.defineProps({
        embedPDF:{
            get:function () {
                return this.getAttribute("embedPDF");
            },
            set:function (value) {
                this.setAttribute(value, "embedPDF");
            }
        },
        format:{
            get:function () {
                return this.getAttribute("format");
            },
            set:function (value) {
                this.setAttribute(value, "format");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        textEncoding:{
            get:function () {
                return this.getAttribute("textEncoding");
            },
            set:function (value) {
                this.setAttribute(value, "textEncoding");
            }
        },
        xdpContent:{
            get:function () {
                return this.getAttribute("xdpContent");
            },
            set:function (value) {
                this.setAttribute(value, "xdpContent");
            }
        },
        encrypt:{
            get:function () {
                return this.getElement("encrypt", 0);
            },
            set:function (value) {
                this.setElement(value, "encrypt");
            }
        }


    });

})(_, xfalib);
(function (_, xfalib) {
    var Svg = xfalib.script.dom.Svg = xfalib.script.GenericText.extend({
        msClassName:"svg"
    });

    Svg.defineProps({
        height:{
            get:function () {
                return this.getAttribute("height");
            },
            set:function (value) {
                this.setAttribute(value, "height");
            }
        },
        viewBox:{
            get:function () {
                return this.getAttribute("viewBox");
            },
            set:function (value) {
                this.setAttribute(value, "viewBox");
            }
        },
        width:{
            get:function () {
                return this.getAttribute("width");
            },
            set:function (value) {
                this.setAttribute(value, "width");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var TextEdit = xfalib.script.dom.TextEdit = xfalib.script.DOMElement.extend({
        msClassName:"textEdit"
    });

    TextEdit.defineProps({
        allowRichText:{
            get:function () {
                return this.getAttribute("allowRichText");
            },
            set:function (value) {
                this.setAttribute(value, "allowRichText");
            }
        },
        hScrollPolicy:{
            get:function () {
                return this.getAttribute("hScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "hScrollPolicy");
            }
        },
        multiLine:{
            get:function () {
                return this.getAttribute("multiLine");
            },
            set:function (value) {
                this.setAttribute(value, "multiLine");
            }
        },
        vScrollPolicy:{
            get:function () {
                return this.getAttribute("vScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "vScrollPolicy");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        comb:{
            get:function () {
                return this.getElement("comb", 0);
            },
            set:function (value) {
                this.setElement(value, "comb");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var TextNode = xfalib.script.TextNode = xfalib.script.Object.extend({
        msClassName:"textNode"
    });

    TextNode.defineProps({

    })
})(_, xfalib);
(function (_, xfalib) {
    var TimeStamp = xfalib.script.dom.TimeStamp = xfalib.script.GenericText.extend({
        msClassName:"timeStamp"
    });

    TimeStamp.defineProps({
        server:{
            get:function () {
                return this.getAttribute("server");
            },
            set:function (value) {
                this.setAttribute(value, "server");
            }
        },
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var ToolTip = xfalib.script.dom.ToolTip = xfalib.script.GenericText.extend({
        msClassName:"toolTip"
    });

    ToolTip.defineProps({
        rid:{
            get:function () {
                return this.getAttribute("rid");
            },
            set:function (value) {
                this.setAttribute(value, "rid");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Traversal = xfalib.script.dom.Traversal = xfalib.script.DOMElement.extend({
        msClassName:"traversal"
    });

    Traversal.defineProps({
        passThrough:{
            get:function () {
                return this.getAttribute("passThrough");
            },
            set:function (value) {
                this.setAttribute(value, "passThrough");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Traverse = xfalib.script.dom.Traverse = xfalib.script.DOMElement.extend({
        msClassName:"traverse"
    });

    Traverse.defineProps({
        delegate:{
            get:function () {
                return this.getAttribute("delegate");
            },
            set:function (value) {
                this.setAttribute(value, "delegate");
            }
        },
        operation:{
            get:function () {
                return this.getAttribute("operation");
            },
            set:function (value) {
                this.setAttribute(value, "operation");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Ui = xfalib.script.dom.Ui = xfalib.script.DOMElement.extend({
        msClassName:"ui",

        // TODO : remove these once Sharad merges changes from HMRC
        initialize : function(){
            Ui._super.initialize.call(this);
            for (var i = 0; i < this.moChildNodes.length; ++i) {
                var oNode = this.moChildNodes[i];
                oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED,this) ;
            }
        },

        handleEvent: function(evnt) {
            this.trigger(evnt.name,evnt);
        },

        _getOneOfChild : function(){
            var oneChild = Ui._super._getOneOfChild.call(this);
            if(oneChild)
                return oneChild;

            var childType = "textEdit";
            if(this.parent){
                var valueChild = this.parent.value.oneOfChild || {className : "text"};
                switch (valueChild.className){
                    case "dateTime" :
                    case "date" :
                    case "time" :
                        childType = "dateTimeEdit";
                        break;
                    case "decimal" :
                    case "float" :
                    case "integer" :
                        childType = "numericEdit";
                        break;
                    case "boolean" :
                        childType = "checkButton";
                        break;
                    case "text" :
                        childType = "textEdit";
                        break;
                    case "image" :
                        childType = "imageEdit";
                        break;
                }
            }
            return this._getDefaultElement(childType, 0, true);
        }

    });

    Ui.defineProps({
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        },
        barcode:{
            get:function () {
                return this.getElement("barcode", 0);
            },
            set:function (value) {
                this.setElement(value, "barcode");
            }
        },
        button:{
            get:function () {
                return this.getElement("button", 0);
            },
            set:function (value) {
                this.setElement(value, "button");
            }
        },
        checkButton:{
            get:function () {
                return this.getElement("checkButton", 0);
            },
            set:function (value) {
                this.setElement(value, "checkButton");
            }
        },
        choiceList:{
            get:function () {
                return this.getElement("choiceList", 0);
            },
            set:function (value) {
                this.setElement(value, "choiceList");
            }
        },
        dateTimeEdit:{
            get:function () {
                return this.getElement("dateTimeEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "dateTimeEdit");
            }
        },
        defaultUi:{
            get:function () {
                return this.getElement("defaultUi", 0);
            },
            set:function (value) {
                this.setElement(value, "defaultUi");
            }
        },
        exObject:{
            get:function () {
                return this.getElement("exObject", 0);
            },
            set:function (value) {
                this.setElement(value, "exObject");
            }
        },
        imageEdit:{
            get:function () {
                return this.getElement("imageEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "imageEdit");
            }
        },
        numericEdit:{
            get:function () {
                return this.getElement("numericEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "numericEdit");
            }
        },
        passwordEdit:{
            get:function () {
                return this.getElement("passwordEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "passwordEdit");
            }
        },
        signature:{
            get:function () {
                return this.getElement("signature", 0);
            },
            set:function (value) {
                this.setElement(value, "signature");
            }
        },
        textEdit:{
            get:function () {
                return this.getElement("textEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "textEdit");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Validate = xfalib.script.dom.Validate = xfalib.script.DOMElement.extend({
        msClassName:"validate"
    });

    Validate.defineProps({
        disableAll:{
            get:function () {
                return this.getAttribute("disableAll");
            },
            set:function (value) {
                this.setAttribute(value, "disableAll");
            }
        },
        formatTest:{
            get:function () {
                return this.getAttribute("formatTest");
            },
            set:function (value) {
                this.setAttribute(value, "formatTest");
            }
        },
        nullTest:{
            get:function () {
                return this.getAttribute("nullTest");
            },
            set:function (value) {
                var oldValue = this.nullTest;
                this.setAttribute(value, "nullTest");
                var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED, this,
                        'nullTest', oldValue, value);
                this.trigger(event.name, event);
            }
        },
        scriptTest:{
            get:function () {
                return this.getAttribute("scriptTest");
            },
            set:function (value) {
                this.setAttribute(value, "scriptTest");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        message:{
            get:function () {
                return this.getElement("message", 0);
            },
            set:function (value) {
                this.setElement(value, "message");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Value = xfalib.script.dom.Value = xfalib.script.DOMElement.extend({
        msClassName: "value",

        _getOneOfChild: function () {
            var oneChild = Value._super._getOneOfChild.call(this);
            if (oneChild)
                return oneChild;

            var childType = "text";
            if (this.parent && (this.parent.className == "field" || this.parent.className == "draw")) {
                /*
                 * Bug:3600246
                 * When checking ui oneOfChild, do not directly use ui.oneOfChild since it would again fallback to value.onOfChild in case value is also missing.
                 * So check json instead and see if ui oneOfChild exist and then only access it.
                 */
                var uiChild = this.xfaUtil().getUiOneOfChildTag(this.parent.jsonModel) ? this.parent.ui.oneOfChild : {className: "text"};
                switch (uiChild.className) {
                    case "numericEdit" :
                        childType = "float";
                        break;
                    case "dateTimeEdit" :
                        childType = "dateTime";
                        break;
                    case "imageEdit" :
                        childType = "image";
                        break;
                    case "textEdit" :
                        if (uiChild.allowRichText) {
                            childType = "exData";
                        }
                        else {
                            childType = "text";
                        }
                        break;
                    case "choiceList" :
                        if (uiChild.open == "multiSelect") {
                            childType = "exData";
                        }
                        else {
                            childType = "text";
                        }
                        break;
                }
            }
            return this._getDefaultElement(childType, 0, true);
        },

        _computeJsonDiff: function (diff_level) {

            //Force all the descendants of value irrespective of submit call
            var diffObj = xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, false, Value._super._computeJsonDiff, [0]);

            //now strip all the EXTRA properties from value if it is final submission  or restoreFormState
            if (diff_level>0 && this.getOrElse(diffObj, 'jsonDifference.children.length', 0)) {
                //believe me this is not that costly as it looks to be as there will be only one child in all the differences and only two keys per child
                var blacklisted = ['extras'];
                diffObj.jsonDifference.children = _.map(diffObj.jsonDifference.children, function (child) {
                    var copy = {};
                    _.each(Object.keys(child), function (key) {
                        if (!_.contains(blacklisted, key)) {
                            copy[key] = child[key];
                        }
                    });
                    return copy;
                }, this);
            }

            //LC-8319 : don't send [] in diffObj.jsonDifference.children
            if (diffObj.jsonDifference && _.every(diffObj.jsonDifference.children, _.isEmpty)) {  // diffObj should have a jsonDifference member
                diffObj.jsonDifference.children = undefined; // scary to use delete due to perf. impact
            }
            return diffObj;
        }

    });

    Value.defineProps({
        override: {
            get: function () {
                return this.getAttribute("override");
            },
            set: function (value) {
                this.setAttribute(value, "override");
            }
        },
        relevant: {
            get: function () {
                return this.getAttribute("relevant");
            },
            set: function (value) {
                this.setAttribute(value, "relevant");
            }
        },
        arc: {
            get: function () {
                return this.getElement("arc", 0);
            },
            set: function (value) {
                this.setElement(value, "arc");
            }
        },
        "boolean": {
            get: function () {
                return this.getElement("boolean", 0);
            },
            set: function (value) {
                this.setElement(value, "boolean");
            }
        },
        "date": {
            get: function () {
                return this.getElement("date", 0);
            },
            set: function (value) {
                this.setElement(value, "date");
            }
        },
        "dateTime": {
            get: function () {
                return this.getElement("dateTime", 0);
            },
            set: function (value) {
                this.setElement(value, "dateTime");
            }
        },
        "decimal": {
            get: function () {
                return this.getElement("decimal", 0);
            },
            set: function (value) {
                this.setElement(value, "decimal");
            }
        },
        exData: {
            get: function () {
                return this.getElement("exData", 0);
            },
            set: function (value) {
                this.setElement(value, "exData");
            }
        },
        "float": {
            get: function () {
                return this.getElement("float", 0);
            },
            set: function (value) {
                this.setElement(value, "float");
            }
        },
        "image": {
            get: function () {
                return this.getElement("image", 0);
            },
            set: function (value) {
                this.setElement(value, "image");
            }
        },
        "integer": {
            get: function () {
                return this.getElement("integer", 0);
            },
            set: function (value) {
                this.setElement(value, "integer");
            }
        },
        line: {
            get: function () {
                return this.getElement("line", 0);
            },
            set: function (value) {
                this.setElement(value, "line");
            }
        },
        rectangle: {
            get: function () {
                return this.getElement("rectangle", 0);
            },
            set: function (value) {
                this.setElement(value, "rectangle");
            }
        },
        "text": {
            get: function () {
                return this.getElement("text", 0);
            },
            set: function (value) {
                this.setElement(value, "text");
            }
        },
        "time": {
            get: function () {
                return this.getElement("time", 0);
            },
            set: function (value) {
                this.setElement(value, "time");
            }
        }
    });

})(_, xfalib);

(function(_, $, xfalib){

    var HtmlTemplateCache = xfalib.view.util.HtmlTemplateCache = xfalib.ut.Class.extend({
        initialize : function(){
            HtmlTemplateCache._super.initialize.call(this);
            this._cache = {};
            this._hiddenObjPages = [];
        },

        put: function (el) {
            var occurIndex = this.getOrElse(this.xfaUtil().$data(el, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL + "." + xfalib.view.LayoutConst.OCCUR_INDEX, '0');
            if (!this.contains(el.id) || this._cache[el.id][occurIndex] === undefined) {
                this._cache[el.id] = this._cache[el.id] || {};
                this._cache[el.id][occurIndex] = el; // the cache is now 2D, against each el id store a map, indexed by occur index
                this._cacheChildren(el);
            }
        },

        contains : function(elId){
            return (this._cache.hasOwnProperty(elId) && this._cache[elId] !== undefined);
        },

        get : function(elId, lookUpHiddenCache){
            var $nodeDiv = null,
                nodeXfaModel = null,
                partOffsetY = 0,
                $pageDiv,
                $splitPart;

            function stitchNodes() {
                // We need to collect all parts of this node from various pages/occurrences and stitch them together.
                // We start by picking *stitched* children of this part and append them to initially empty $nodeDiv. As we move on to next
                // part, we'll pick only those children which starts from that part(occurIndex:0)
                // Stitching would require modify the extenty of children to add content height of current stitched
                // part and then modify the extenth of currently stitched part to include height of new part. All the children from new part are cloned-appended into
                // current stitch part.

                if (!$nodeDiv) {
                    //do not modify existing node. Work on it's clone and start building from scratch.
                    $nodeDiv = $splitPart.clone();
                    $nodeDiv.children().remove();
                    nodeXfaModel = this.xfaUtil().$data($nodeDiv.get(0), xfalib.view.LayoutConst.XFA_MODEL);
                }
                else {
                    partOffsetY = parseFloat(nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_H]) -
                        parseFloat(this.getOrElse(nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.MARGIN_TOP], 0)) -
                        parseFloat(this.getOrElse(nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.MARGIN_BOTTOM], 0));
                }

                _.each($splitPart.children().get(),
                    function (partChild) {
                        var childId = partChild.id;
                        var childHasSplit = (this.getOrElse(this.xfaUtil().$data(partChild, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL + "." + xfalib.view.LayoutConst.OCCURRENCES, 1) > 1);
                        var isChildFirstSplit = (this.getOrElse(this.xfaUtil().$data(partChild, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL + "." + xfalib.view.LayoutConst.OCCUR_INDEX, 0) == 0);
                        var $childClone = null;
                        if (childHasSplit && !isChildFirstSplit) {
                            //split child would already been handled when it's first part was found.
                            return;
                        }
                        else if (childHasSplit && isChildFirstSplit) {
                            //If this child has split and it is first part of the child split, get the entire stitched child.
                            $childClone = $(this.get(childId, true));
                        }
                        else {
                            $childClone = $(partChild).clone();
                        }
                        var childXfaModel = this.xfaUtil().$data($childClone.get(0), xfalib.view.LayoutConst.XFA_MODEL);
                        if (childXfaModel) {
                            // modify the extenty of child and then append this child clone to current stitch part $nodeDiv
                            childXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_Y] = partOffsetY + parseFloat(this.getOrElse(childXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_Y], 0));
                            $childClone.attr("data-" + xfalib.view.LayoutConst.XFA_MODEL, JSON.stringify(childXfaModel));
                        }
                        $childClone.appendTo($nodeDiv);
                    },
                    this
                );

                // modify the extenth part $nodeDiv
                nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_H] = parseFloat(this.xfaUtil().$data($splitPart.get(0), xfalib.view.LayoutConst.XFA_MODEL)[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_H]) + partOffsetY;
            }

            if(this.contains(elId)) {
                if(_.keys(this._cache[elId]).length === 1) {
                    return this._cache[elId]["0"].cloneNode(true);
                }
                // subform was split into different parts, stitch each part in order of occurIndex
                for (var occurIndex = 0; occurIndex < _.keys(this._cache[elId]).length; ++occurIndex) {
                    $splitPart = $(this._cache[elId][occurIndex]);
                    stitchNodes.call(this);
                }

                if ($nodeDiv && $nodeDiv.get(0)) {
                // update stitched node in cache, after modifying occurrences and occur index to make it appear as unsplit
                    this._cache[elId] = undefined;
                    nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.OCCURRENCES] = "1";
                    nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.OCCUR_INDEX] = undefined;
                }
            }
            else if(lookUpHiddenCache) {
                for(var i = 0; i < this._hiddenObjPages.length; ++i) {
                    $pageDiv = $(this._hiddenObjPages[i]);
                    $splitPart = $pageDiv.find(this.jqId(elId));
                    if($splitPart && $splitPart.get(0)){
                        stitchNodes.call(this);
                    }
                    this._hiddenObjPages[i] = $pageDiv.get(0); // cache the constructed page dom back in hidden objects array in case page was string as it happens for the first time.
                }
            }

            if ($nodeDiv && $nodeDiv.get(0)) {
                $nodeDiv.attr("data-" + xfalib.view.LayoutConst.XFA_MODEL, JSON.stringify(nodeXfaModel));
                this.put($nodeDiv.get(0));  //put it in the cache.
                return $nodeDiv.get(0).cloneNode(true);
            }
            else {
                return null;
            }
        },

        setHiddenObjPages : function(hiddenPages){
            this._hiddenObjPages = hiddenPages || [];
        },

        _cacheChildren : function(parent){
            var that = this;
            $(parent).children().each(function(){
                //cache xfa sub elements as well.
                if(that.getOrElse(that.xfaUtil().$data(this, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.NODE_TYPE, "").length > 0){
                    that.put(this);
                }
            });
        }
    });
})(_, $, xfalib);
(function(_,xfalib) {
    var Constants = {
        XFA_MODEL : "x",
        NODE_TYPE : "t",
        LAYOUT_MODEL: "l",
        SUBFORM_LAYOUT: "sl",
        EXTENT_X : "x",
        EXTENT_Y : "y",
        EXTENT_W : "w",
        EXTENT_H : "h",
        EXTENT_MIN_H : "nh",
        EXTENT_MIN_W : "nw",
        EXTENT_MAX_H : "xh",
        EXTENT_MAX_W : "xw",
        EXTENT_ACTUAL_H : "ah",
        EXTENT_ACTUAL_W : "aw",
        MARGIN_TOP : "t",
        MARGIN_LEFT : "l",
        MARGIN_BOTTOM : "b",
        MARGIN_RIGHT : "r",

        BORDER_TOP : "bt",
        BORDER_LEFT : "bl",
        BORDER_BOTTOM : "bb",
        BORDER_RIGHT : "br",

        COL_SPAN : "c",
        ROW_SPAN : "rs",
        OCCURRENCES : "o",
        OCCUR_INDEX: "i",
        COLUMN_WIDTHS : "cw",
        PAGE_NUMBER: "pn",
        CAP_PLACEMENT : "p",
        LAYOUT_LEFTRIGHTTOPBOTTOM : "lr",
        LAYOUT_RIGHTLEFTTOPBOTTOM : "rl",
        LAYOUT_TOPBOTTOM : "tb",
        LAYOUT_TABLE : "t",
        LAYOUT_ROW : "r",
        LAYOUT_RIGHTLEFTROW : "rr",
        LAYOUT_DATATABLE : "dt"
    };
    xfalib.view.LayoutConst = Constants;
})(_,xfalib);
(function(_, $, xfalib){
    var LayoutBase = xfalib.view.layout.LayoutBase = xfalib.ut.Class.extend({
        initialize : function(){
            xfalib.ut.Class.prototype.initialize.apply(this, arguments);
            this._layoutManager = this._xfaViewRegistry().layoutManager();
            this.target = this.options.target; //ContainerView instance
            this._positioningCssPropertyX = "left";
            this._positioningCssPropertyY = "top";
        },

        measureSize : function(){
            return xfalib.view.BaseView.prototype.measureSize.apply(this.target, arguments);
        },

        invalidateSize : function(){
            return xfalib.view.BaseView.prototype.invalidateSize.apply(this.target, arguments);
        },

        updateDisplay : function(){
            xfalib.view.BaseView.prototype.updateDisplay.apply(this.target, arguments);
            _.each(this.target._normalizedChildViews(), function(childView, index){
                var extent = {};
                extent[this._positioningCssPropertyX] =  childView.layoutModel.measuredx;
                extent[this._positioningCssPropertyY] =  childView.layoutModel.measuredy;
                this.$css(childView.el, extent);
            }, this);
        },

        _targetPaddingX : function(){
            return this.target._padLeft();
        },

        _targetPaddingY : function(){
            return this.target._padTop();
        },

        $data : xfalib.ut.XfaUtil.prototype.$data,

        $css : xfalib.ut.XfaUtil.prototype.$css,

        _xfaViewRegistry : function() {
            return window.xfaViewRegistry;    //TODO: remove window dependency
        }

    })

})(_, $, xfalib);


(function(_, $, xfalib){
    xfalib.view.layout.PositionLayout = xfalib.view.layout.LayoutBase.extend({
        initialize : function(){
            xfalib.view.layout.LayoutBase.prototype.initialize.apply(this, arguments);
        },

        measureSize : function(){
            var layoutModel = this.target.layoutModel;
            var parentPadLeft = this._targetPaddingX();
            var parentPadTop = this._targetPaddingY();
            var oldExtentW = layoutModel.extentw;
            var oldExtentH = layoutModel.extenth;
            var containerW = 0;
            var containerH = 0;
            _.each(this.target._normalizedChildViews(), function(childView, index){

                childView.layoutModel.measuredx =  parentPadLeft + childView.layoutModel.extentx;
                childView.layoutModel.measuredy =  parentPadTop + childView.layoutModel.extenty;
                if(childView.layoutModel.extentx + childView.layoutModel.extentw > containerW)
                    containerW = childView.layoutModel.extentx + childView.layoutModel.extentw;
                if(childView.layoutModel.extenty + childView.layoutModel.extenth > containerH)
                    containerH = childView.layoutModel.extenty + childView.layoutModel.extenth;
            }, this);

            if(layoutModel.extentactualw < 0){
                var parentExtentW = layoutModel.marginleft + containerW + layoutModel.marginright;
                layoutModel.extentw = parentExtentW;
            }
            if(layoutModel.extentactualh < 0){
                var parentExtentH = layoutModel.margintop + containerH + layoutModel.marginbottom;
                layoutModel.extenth = parentExtentH;
            }

            if(oldExtentW != layoutModel.extentw || oldExtentH != layoutModel.extenth){
                return true;
            }
            else {
                return false;
            }
        }

    })
})(_, $, xfalib);



(function(_, $, xfalib){
    xfalib.view.layout.LeftRightLayout = xfalib.view.layout.LayoutBase.extend({
        initialize : function(){
            xfalib.view.layout.LayoutBase.prototype.initialize.apply(this, arguments);
        },

        measureSize : function(){
            var layoutModel = this.target.layoutModel;
            var parentPadX = this._targetPaddingX();
            var parentPadY = this._targetPaddingY();
            var oldExtentW = layoutModel.extentw;
            var oldExtentH = layoutModel.extenth;
            var parentContentWidth  =  layoutModel.extentw - layoutModel.marginleft - layoutModel.marginright + this._layoutManager.LAYOUT_ERROR_MARGIN;
            if(layoutModel.extentactualw < 0){
                parentContentWidth = 1000000; //Arbitrary limitation for max width. Could be MAX_VALUE, but that may be costly?
            }

            var currentX =  0;//Right of the last element
            var currentLineY = 0;
            var lineHeight = 0; //Line Height for current line
            _.each(this.target._normalizedChildViews(), function(childView, index){
                if(currentX + childView.layoutModel.extentw > parentContentWidth){
                    currentX = 0;
                    currentLineY = currentLineY + lineHeight;
                    lineHeight = 0;
                }
                childView.layoutModel.measuredx =  parentPadX + currentX;
                childView.layoutModel.measuredy = parentPadY + currentLineY;
                if(lineHeight < childView.layoutModel.extenth){
                    lineHeight = childView.layoutModel.extenth;
                }
                //update top variables for second element
                currentX = currentX +  childView.layoutModel.extentw;
            }, this);
            if(layoutModel.extentactualw < 0) {
                var parentExtentW = layoutModel.marginleft + currentX + layoutModel.marginright;
                layoutModel.extentw = parentExtentW;
            }
            if(layoutModel.extentactualh < 0) {
                var parentExtentH = layoutModel.margintop + currentLineY + lineHeight + layoutModel.marginbottom;
                layoutModel.extenth = parentExtentH;
            }

            if(oldExtentW != layoutModel.extentw || oldExtentH != layoutModel.extenth){
                return true;
            }
            else{
                return false;
            }
        }

    })
})(_, $, xfalib);

(function(_, $, xfalib){
    xfalib.view.layout.RightLeftLayout = xfalib.view.layout.LeftRightLayout.extend({
        initialize : function(){
            xfalib.view.layout.LeftRightLayout.prototype.initialize.apply(this, arguments);
            this._positioningCssPropertyX = "right";
            this._positioningCssPropertyY = "top";
        },

        _targetPaddingX : function(){
            return this.target._padRight();
        },

        _targetPaddingY : function(){
            return this.target._padTop();
        }

    })
})(_, $, xfalib);


(function(_, $, xfalib){
    xfalib.view.layout.TopBottomLayout = xfalib.view.layout.LayoutBase.extend({

        measureSize : function(){
            var layoutModel = this.target.layoutModel;
            var parentPadLeft = this._targetPaddingX();
            var parentPadTop = this._targetPaddingY();
            var oldExtentW = layoutModel.extentw;
            var oldExtentH = layoutModel.extenth;
            var containerW = 0;
            var currentLineY  =  0;
            _.each(this.target._normalizedChildViews(), function(childView, index){
                childView.layoutModel.measuredx = parentPadLeft;
                childView.layoutModel.measuredy =  parentPadTop + currentLineY;
                if(childView.layoutModel.extentw > containerW) {
                    containerW = childView.layoutModel.extentw;
                }
                //update currentLineY variables for second element
                currentLineY = currentLineY + childView.layoutModel.extenth;
            }, this);

            if(layoutModel.extentactualw < 0){
                var parentExtentW = layoutModel.marginleft + containerW + layoutModel.marginright;
                layoutModel.extentw = parentExtentW;
            }
            if(layoutModel.extentactualh < 0){
                var parentExtentH = layoutModel.margintop + currentLineY + layoutModel.marginbottom;
                layoutModel.extenth = parentExtentH;
            }

            if(oldExtentW != layoutModel.extentw || oldExtentH != layoutModel.extenth){
                return true;
            }
            else {
                return false;
            }
        }

    })
})(_, $, xfalib);


(function(_, $, xfalib){
    xfalib.view.layout.RowLayout = xfalib.view.layout.LayoutBase.extend({
        initialize : function(){
            xfalib.view.layout.LayoutBase.prototype.initialize.apply(this, arguments);
        },

        measureSize : function(){
            var layoutModel = this.target.layoutModel;
            var lineHeight = 0; //Line Height for current line
            _.each(this.target._normalizedChildViews(), function(childView, index){
//                if(childView.model && childView.model.className == "draw")      //Draw table cells are set to 100% sizes. They can not grow. If moved, they'll overlay border
//                    return;
                if(lineHeight < childView.layoutModel.extenth){
                    lineHeight = childView.layoutModel.extenth;
                }
            }, this);
            //Set extenth for all row cells
            _.each(this.target._normalizedChildViews(), function(childView, index){
                if(childView.layoutModel.extenth != lineHeight){
                    childView.layoutModel.extenth = lineHeight;
                    childView.invalidateDisplay();
                }
            }, this);

            layoutModel.extenth = layoutModel.margintop + lineHeight + layoutModel.marginbottom;

            //in case of rowLayout measure would always return true which means
            // layout algo of table would always be triggered as row does not have enough data to compute if any column width changed
            return true;
        }

    })
})(_, $, xfalib);


(function(_, $, xfalib){
    xfalib.view.layout.DataTableRowLayout = xfalib.view.layout.RowLayout.extend({
        initialize : function(){
            xfalib.view.layout.RowLayout.prototype.initialize.apply(this, arguments);
        },

        measureSize : function(){
            //in case of rowLayout measure would always return true which means
            // layout algo of table would always be triggered as row does not have enough data to compute if any column width changed
            return true;
        },

        updateDisplay : function(){
            xfalib.view.layout.RowLayout.prototype.updateDisplay.apply(this, arguments);
            this.$css(this.target.el, {"position":"relative"});
            _.each(this.target._normalizedChildViews(), function(childView){
                var extent = {};
                extent["position"] =  "relative";
                this.$css(childView.el, extent);
                if(childView.layoutModel.borderleft > 2) {
                    this.$css(childView.el, {"border-left-width":childView.layoutModel.borderleft/2.0});
                }
                if(childView.layoutModel.bordertop > 2) {
                    this.$css(childView.el, { "border-top-width":childView.layoutModel.bordertop/2.0});
                }
                if(childView.layoutModel.borderbottom > 2) {
                    this.$css(childView.el, {"border-bottom-width":childView.layoutModel.borderbottom/2.0});
                }
                if(childView.layoutModel.borderright > 2) {
                    this.$css(childView.el, {"border-right-width":childView.layoutModel.borderright/2.0});
                }
            }, this);

        }
    })
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.layout.RightLeftRowLayout = xfalib.view.layout.RowLayout.extend({
        initialize : function(){
            xfalib.view.layout.RowLayout.prototype.initialize.apply(this, arguments);
            this._positioningCssPropertyX = "right";
            this._positioningCssPropertyY = "top";
        },

        _targetPaddingX : function(){
            return this.target._padRight();
        },

        _targetPaddingY : function(){
            return this.target._padTop();
        }
    })
})(_, $, xfalib);



(function(_, $, xfalib){
    xfalib.view.layout.TableLayout = xfalib.view.layout.LayoutBase.extend({
        initialize : function(){
            xfalib.view.layout.LayoutBase.prototype.initialize.apply(this, arguments);
            this._tableCellGrid = [ [] ];
            this.assignedColWidths = this.getOrElse(this.target.layoutModel.columnwidths, []);
            this._columnWidths = this.assignedColWidths.slice();
        },

        /**
         * Returns the Rows in the table by filtering out rows from all the child views
         * @returns Array containing the child views that are rows
         * @private
         */
        _getRows : function () {
            return _.filter(this.target._normalizedChildViews(), function (childView) {
                if (childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW
                        || childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) {
                    return true;
                } else {
                    return false;
                }
            }, this);
        },

        measureSize : function () {
            var layoutModel = this.target.layoutModel,
                rowViews = this._getRows();

            this._validCellsInRow(rowViews);

            _.each(rowViews, function(rowView, rowIndex){
                _.each(rowView._normalizedChildViews(), function(cellView){
                    var cellLayout = cellView.layoutModel;
                    var colspan = this.getOrElse(cellLayout.colspan, 1);
                    if(colspan == -1)
                        colspan = this._tableCellGrid.length - cellView.effectiveCellIndex; //if colpan is -1, then set it to remaining grid length
                    var lastCellIndex = cellView.effectiveCellIndex + colspan -1;

                    if(!this._tableCellGrid[lastCellIndex]){
                        var lastNonEmptyColIndex = -1;
                        for(var j = lastCellIndex; j>=0; j-- ){
                            if(this._tableCellGrid[j]){
                                lastNonEmptyColIndex = j;
                                break;
                            }
                        }
                        //lastNonEmptyColIndex can not be -1 here. since it should be at least 0
                        //Now copy fill all previous missing column data with lastNonEmptyCol data
                        for(var k = lastNonEmptyColIndex + 1; k <= lastCellIndex ; k++){
                            this._tableCellGrid[k] = this._tableCellGrid[k-1].splice() ;
                        }
                    }
                    //Now add currentCellView to proper location in cell grid
                    for(var i = cellView.effectiveCellIndex; i <= lastCellIndex;  i++){
                        this._tableCellGrid[i][rowIndex] = cellView;
                    }

                    if(this.assignedColWidths[cellView.effectiveCellIndex] > -1){
                        this._columnWidths[cellView.effectiveCellIndex] = this.assignedColWidths[cellView.effectiveCellIndex];
                        return;
                    }
                    else if(this.getOrElse(cellLayout.colspan, 1) == 1){ // use actual colspan
                        //TODO:check if tableCellIndex maintained properly
                        if(cellLayout.extentw > (this._columnWidths[cellView.effectiveCellIndex] || 0))
                            this._columnWidths[cellView.effectiveCellIndex]  = cellLayout.extentw;
                    }
                }, this);
            }, this);

            //Additional pass to adjust columnWidths for columns with colpsan > 1
            _.each(this._tableCellGrid, function(columnCells, colIndex){
                if(this.assignedColWidths[colIndex] > -1)
                    return;
                var colWidth = this._columnWidths[colIndex];
                _.each(columnCells, function(cellView){
                    var colspan = this.getOrElse(cellView.layoutModel.colspan, "1");
                    if(colspan == -1)
                        colspan = this._tableCellGrid.length - cellView.effectiveCellIndex;
                    //If colspan is one, we have already taken care. if this cell still extends beyond this column, we'll handle it later
                    if( colspan == 1 || ((cellView.effectiveCellIndex + colspan -1) != colIndex))
                        return;
                    //For spanned column, compute the with of the cell that lies in this cloumn.
                    var spannedColWidth = cellView.layoutModel.extentw;
                    for(var l = cellView.effectiveCellIndex; l < colIndex; l++){
                        spannedColWidth = spannedColWidth - this._columnWidths[l];
                    }
                    if(spannedColWidth > this._columnWidths[colIndex])
                        this._columnWidths[colIndex] = spannedColWidth;
                }, this);
            }, this);

            //Now update the final computed extentw for cells and rows.
            //Also update measuredx/y for it's cells
            _.each(rowViews, function(rowView, rowIndex){
                var rowPadX = rowView.layout._targetPaddingX();
                var rowPadY = rowView.layout._targetPaddingY();
                var rowWidth = 0;
                _.each(rowView._normalizedChildViews(), function(cellView){
                    var newCellW = this._computeColumnWidth(cellView);
                    if(newCellW != cellView.layoutModel.extentw){
                        cellView.layoutModel.extentw = newCellW;
                        cellView.invalidateDisplay();
                    }
                    cellView.layoutModel.measuredx = rowPadX + rowWidth;
                    cellView.layoutModel.measuredy = rowPadY;
                    rowWidth = rowWidth + cellView.layoutModel.extentw;
                }, this);
                var newRowWidth = rowView.layoutModel.marginleft + rowWidth + rowView.layoutModel.marginright;
                if(rowView.layoutModel.extentw != newRowWidth){
                    rowView.layoutModel.extentw = newRowWidth;
                    rowView.invalidateDisplay();
                }
            }, this);

            //Now update the final computed extentw for table and measuredx/y for it's children
            var tablePadX = this._targetPaddingX();
            var tablePadY = this._targetPaddingY();
            var parentW = 0;
            var parentH = 0;
            _.each(this.target._normalizedChildViews(), function(childView, childIndex){
                if(childView.layoutModel.extentw > parentW){
                    parentW = childView.layoutModel.extentw;
                }
                childView.layoutModel.measuredx = tablePadX;
                childView.layoutModel.measuredy = tablePadY + parentH;
                parentH = parentH + childView.layoutModel.extenth;
            }, this);

            var oldExtentW = layoutModel.extentw;
            var oldExtentH = layoutModel.extenth;
            layoutModel.extentw = layoutModel.marginleft + parentW + layoutModel.marginright;
            layoutModel.extenth = layoutModel.margintop + parentH + layoutModel.marginbottom;
            if(oldExtentW != layoutModel.extentw || oldExtentH != layoutModel.extenth){
                return true;
            }
            else {
                return false;
            }
        },

        _computeColumnWidth : function(cellView){
            var colspan = this.getOrElse(cellView.layoutModel.colspan, 1);
            if(colspan <0){
                colspan = this._columnWidths.length - cellView.tableCellIndex;
            }
            if(cellView.effectiveCellIndex + colspan -1 >= this._columnWidths.length)
                return cellView.layoutModel.extentw;              //should not be the case ever
            else{
                var colWidth = 0;
                for(var i= cellView.effectiveCellIndex; i <= cellView.effectiveCellIndex + colspan -1; i++){
                    colWidth = colWidth + this._columnWidths[i];
                }
                return colWidth;
            }
        },

        _validCellsInRow : function(rowViews) {
            var hiddenChildIndex;
            var index;
            var count =0;

            _.each(rowViews, function(rowView, rowIndex){
                var ChildViews = rowView.childViews;
                hiddenChildIndex = [];
                _.each(ChildViews,function(vChildView, index){
                       if(vChildView.model.presence != "visible") {
                          hiddenChildIndex.push(index);  // keeps the index of hidden fields
                       }
                  },this);


                  for(var i=ChildViews.length-1;i>0;i--) {
                     count = 0;
                     _.each(hiddenChildIndex,function(value,index){ // this is to find the number of hidden elements before the given index.
                         if(value < i) count++;
                     },this);
                     ChildViews[i].effectiveCellIndex = ChildViews[i].tableCellIndex - count ; // to calculate the effective cell index for visible fields.
                  }

            },this);
        },

        //layout related functions
        invalidateSize : function(){
            if(!this._layoutManager.isPendingValidateSize(this.target)){ //check isPending to avoid recursion
                _.each(this.target._normalizedChildViews(), function(childView) {
                    if (!this._layoutManager.isPendingValidateSize(childView) && (childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW ||
                            childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW)) {
                        _.each(childView._normalizedChildViews(), function(cellView) {
                            if (!this._layoutManager.isPendingValidateSize(cellView)) {
                                cellView.invalidateSize();
                            }
                        }, this);
                        childView.invalidateSize();
                    }
                }, this);
                xfalib.view.layout.LayoutBase.prototype.invalidateSize.apply(this, arguments);
            }
        }

    })
})(_, $, xfalib);



(function(_, $, xfalib){

    xfalib.view.layout.DataTableLayout = xfalib.view.layout.TableLayout.extend({

        //for a given id get the list of headers (including row-headers and column-headers)
        //this can be multiple in case we have multiple row/column, or cell spans multiple columns
        //TCH: Table Column Header
        //TRH: Table Row Header
        //TDC: Table Data Cell
        getHeader:function(cellId,dataPresenceTable) {
            // use headers as a Set
            var headers = {};
            _.each(dataPresenceTable, function(row, i) {
                _.each(dataPresenceTable[i], function(column, j) {
                    if(cellId == dataPresenceTable[i][j].substring(4)) {
                        var k, header;
                        for(k=0;k<i;k++) {
                            if(dataPresenceTable[k][j].indexOf("TCH:") == 0) {
                                header = dataPresenceTable[k][j].substring(4);
                                if(!headers.hasOwnProperty(header)) {
                                    headers[header] = true;
                                }
                            }
                        }
                        for(k=0;k<j;k++) {
                            if(dataPresenceTable[i][k].indexOf("TRH:") == 0) {
                                header = dataPresenceTable[i][k].substring(4);
                                if(!headers.hasOwnProperty(header)) {
                                    headers[header] = true;
                                }
                            }
                        }
                    }
                },this);
            },this);
            // convert headers Set into string to be added to headers attribute
            return _.keys(headers).join(" ").trim();
        },


        measureSize: function () {
            //heightTable: contains the height for each row
            //widthTable: contains the width for each cell
            //dataPresenceTable: captures the mapping for header to data cells
            var heightTable = [], widthTable = [], dataPresenceTable = [];

            var layoutModel = this.target.layoutModel;
            //get child of tables which are actually rows
            var rowViews = _.filter(this.target._normalizedChildViews(), function (childView) {
                if (childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW || childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW)
                    return true;
                else
                    return false;
            }, this);
            this._validCellsInRow(rowViews);

            //identify the number of columns in the table (the first row is the bet to get this as
            // previous row rowspan does not impact it). Add all colspans to get the actual number of columns
            var numColumns = 0;
            _.each(rowViews, function (rowView, rowIndex) {
                _.each(rowView._normalizedChildViews(), function (cellView, cellIndex) {
                    if(rowIndex == 0){
                        numColumns+=this.getOrElse(cellView.layoutModel.colspan, 1);
                    }
                }, this);
                //initilaize the columns to an __empty string, and the end of processing table will not
                //contain any __empty cells
                dataPresenceTable[rowIndex] = [];
                for(var i=0;i<numColumns;i++) {
                    dataPresenceTable[rowIndex][i] = "__empty";
                }
            },this);


            //Populate the dataPresenceTable with the IDs for header and data cell - required to associate the headers
            // with the data cells. Also populate the height tables needed for formatting the table.
            _.each(rowViews, function (rowView, rowIndex) {
                _.each(rowView._normalizedChildViews(), function (cellView, cellIndex) {
                    var cellLayout = cellView.layoutModel;
                    var rowspan = this.getOrElse(cellLayout.rowspan, 1);
                    var colspan = this.getOrElse(cellLayout.colspan, 1);
                    if (colspan == -1) {
                        //if colpan is -1, then set it to remaining grid length
                        colspan = this._tableCellGrid.length - cellView.effectiveCellIndex;
                    }
                    if(rowspan == 1){
                        if(heightTable[rowIndex] == undefined || cellView.layoutModel.extenth > heightTable[rowIndex] ) {
                            heightTable[rowIndex] = cellView.layoutModel.extenth;
                            if(cellView.layoutModel.extenth < cellView.layoutModel.initialh)
                                heightTable[rowIndex] = cellView.layoutModel.initialh;
                        }
                    }
                    var actualColumnIndex = 0;
                    for (var i = 0; i < numColumns; i++) {
                        if(dataPresenceTable[rowIndex][i] == "__empty") {
                            for(var j=0;j<colspan;j++) {
                                for(var k=0;k<rowspan;k++) {
                                    if(cellView.el.nodeName == "TH") {
                                        if(cellView._isPartOfHeaderRow()) {
                                            dataPresenceTable[rowIndex+k][actualColumnIndex+j] = "TCH:"+cellView._id;
                                        } else {
                                            dataPresenceTable[rowIndex+k][actualColumnIndex+j] = "TRH:"+cellView._id;
                                        }
                                    } else {
                                        dataPresenceTable[rowIndex+k][actualColumnIndex+j] = "TDC:"+cellView._id;
                                    }
                                    if(colspan == 1){
                                        if(widthTable[actualColumnIndex] == undefined || cellView.layoutModel.extentw > widthTable[actualColumnIndex] ) {
                                            widthTable[actualColumnIndex] = cellView.layoutModel.extentw;
                                        }
                                    }
                                }
                            }

                            break;
                        } else {
                            actualColumnIndex++;
                        }
                    }
                    layoutModel.extenth = 0;
                    layoutModel.extentw = 0;
                    _.each(heightTable, function(height) {
                        layoutModel.extenth+=height ;
                    });

                    _.each(widthTable, function(width) {
                        layoutModel.extentw+=width;
                    });

                }, this);
            }, this);

            //set the row and cell height from height table to keep all cells symmetric
            //also add the headers attribute to the view
            _.each(rowViews, function (rowView, rowIndex) {
                var rowPadX = rowView.layout._targetPaddingX();
                var rowPadY = rowView.layout._targetPaddingY();
                rowView.layoutModel.extenth =  heightTable[rowIndex];

                //process the info to get row heights, column heights and first cell
                _.each(rowView._normalizedChildViews(), function (cellView, cellIndex) {
                    var headers = this.getHeader(cellView._id,dataPresenceTable);
                    if(headers != "") {
                        cellView.$el.attr('headers', headers);
                    }
                    if(cellView.layoutModel.rowspan == 1) {
                        cellView.layoutModel.extenth =  heightTable[rowIndex]
                            - cellView.layoutModel.bordertop / 2.0
                            - cellView.layoutModel.borderbottom / 2.0;
                        cellView.invalidateDisplay();

                    }

                },this);
            },this);
            return true;
        },

        updateDisplay : function(){
            xfalib.view.layout.TableLayout.prototype.updateDisplay.apply(this, arguments);
            this.$css(this.target.el, {"border-spacing":"0"});
            // LC-3911668 : Safari does not update the display when a DOM change is done in a table:
            if(xfalib.ut.XfaUtil.prototype.isSafari()) {
                this.target.$el.hide().css("height");this.target.$el.show();
            }
        }

    }, this);
})(_, $, xfalib);
(function (_, $, xfalib) {
    xfalib.view.layout.StaticLayout = xfalib.view.layout.LayoutBase.extend({

        measureSize : function () {
            var growableOffsetH = 0, growableAssignedH, newOffset;
            var initialGrowableBottom = -1;
            var growableView = this.target.growableView;
            var layoutModel = this.target.layoutModel;
            var growF = 0;
            if (!_.isEmpty(growableView)) {
                for (var i = 0; i < growableView.length; i++) {
                    if ((growableView[i].layoutModel.extenth - growableView[i].layoutModel.initialh) > 0) {
                        growF = i;
                    }
                }

                growableAssignedH = growableView[growF].layoutModel.initialh;
                newOffset = growableView[growF].layoutModel.extenth - growableAssignedH;
                initialGrowableBottom = growableView[growF].layoutModel.extenty + growableAssignedH;

                //bug#3475566, make an exception for first page and render it even if there is no content.
                if (!this.target._forceView() &&
                    growableView[growF].layoutModel.extenth <= (growableView[growF].layoutModel.margintop + growableView[growF].layoutModel.marginbottom)) {
                    //All the children of growable subform have either been removed or been hidden. So set it's height to zero as well.
                    growableOffsetH = -layoutModel.initialh;
                    layoutModel.measureddisplay = "hidden";
                }
                else {
                    if (newOffset > 0 || (!this._xfaViewRegistry().pagingConfig().shrinkPageDisabled &&
                        this.target._formDomRoot().host.numPages > 1)) {
                        //If view has overgrown or
                        //pageShrink is enabled and total number of pages are more that one then change the growableOffSet and move everything.
                        growableOffsetH = newOffset;
                        if (newOffset < 0 && this.target instanceof xfalib.view.PageView) {
                            this.target._formDomRoot().host.pagingManager.autoRenderPage();
                        }
                    }
                    layoutModel.measureddisplay = "block";
                }
            }
            var parentPadLeft = this._targetPaddingX();
            var parentPadTop = this._targetPaddingY();
            var oldExtentH = layoutModel.extenth;
            var containerH = layoutModel.initialh + growableOffsetH;
            _.each(this.target.childViews, function (childView, index) {
                childView.layoutModel.measuredx = parentPadLeft + childView.layoutModel.extentx;
                if (childView.layoutModel.extenty >= initialGrowableBottom) {
                    childView.layoutModel.measuredy = parentPadTop + childView.layoutModel.extenty + growableOffsetH;
                } else {
                    childView.layoutModel.measuredy = parentPadTop + childView.layoutModel.extenty;
                }
                if(layoutModel.measureddisplay !== "hidden") {
                    if (childView.model && childView.model.jsonModel && childView.model.jsonModel.presence !== "hidden" &&
                        childView.layoutModel.measuredy + childView.layoutModel.extenth > containerH) {
                        containerH = childView.layoutModel.measuredy + childView.layoutModel.extenth
                    }
                }
            }, this);

            layoutModel.extenth = containerH;
            if (oldExtentH != layoutModel.extenth) {
                return true;
            }
            else {
                return false;
            }
        },

        _getRootView : function () {
            return this._xfaViewRegistry().rootSubformView;
        },

        renderNextPage : function () {
            this._getRootView().renderDeferredPage();
        },

        updateDisplay : function () {
            xfalib.view.layout.LayoutBase.prototype.updateDisplay.apply(this, arguments);
            if (this.getOrElse(this.target, "layoutModel.measureddisplay", "") == "hidden") {
                this.$css(this.target.el, {"display" : "hidden"});
            }
            else {
                this.$css(this.target.el, {"display" : "block"});
            }
        }

    })
})(_, $, xfalib);




(function(_, $, xfalib){
    xfalib.view.layout.SubformSetLayout = xfalib.view.layout.LayoutBase.extend({
        measureSize : function(){
            //Subformset should always return true show that measureSize(0 of parent is called.
            return true;
        },

        invalidateSize : function(){
            if(this.target.parentView){
                this.target.parentView.invalidateSize();
            }
        }

        })
})(_, $, xfalib);




(function(_, $, xfalib){
    xfalib.view.layout.RootSubformLayout = xfalib.view.layout.LayoutBase.extend({
        measureSize : function(){
            return false;
        },

        updateDisplay : function(){
            return;
        }
    })
})(_, $, xfalib);




(function(_, $, xfalib){
    xfalib.view.layout.LayoutManager = xfalib.ut.Class.extend({
        LAYOUT_ERROR_MARGIN : 1,

        initialize : function(){
            xfalib.ut.Class.prototype.initialize.apply(this, arguments);
            this._invalidSizeQ = [];
            this._invalidDisplayQ = [];
            this._validatingSize = false;
            this._validatingDisplay = false;
            this._validationPending = false;
        },

        invalidateSize : function(view){
            if(this._validatingDisplay && view && view instanceof Object){
                xfalib.runtime.xfa.Logger.error("xfaView", "invalidateSize is called while validatingDisplay is running which is an issue. id" + view._id +
                    ", parent id:"+ (view.parentView && (view.parentView instanceof Object)) ? view.parentView._id : view.parentView);
            }

            if(!this._validatingSize && !this._validationPending){
                var that = this;
                this._validationPending = true;
                var timeout = window.setTimeout(function(){
                    that.triggerValidation();
                }, 1);
                xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(timeout);
            }

            var found = this.isPendingValidateSize(view);
            if(!found){
                this._invalidSizeQ.push(view);
            }
        },

        invalidateDisplay : function(view){
            var found = _.find(this._invalidDisplayQ, function(invalidView){
                if(invalidView == view){
                    return true;
                }
            });
            if(!found){
                this._invalidDisplayQ.push(view);
            }
        },

        triggerValidation : function(){
            if(this._validatingSize){
                xfalib.runtime.xfa.Logger.debug("xfaView", "validation is already running");
            }
            this._validationPending = false;
            this._validatingSize = true;
            while(this._invalidSizeQ.length > 0){
                var view = this._invalidSizeQ.shift();
                view._validateSize();
            }
            this._validatingSize = false;
            if (this._xfaViewRegistry().rootSubformView._formDomRoot()._modelInitialize === 'INITIALIZED') {
                this._xfaViewRegistry().rootSubformView._formDomRoot().form.execLayoutReady();
            }

            this._validatingDisplay = true;
            while(this._invalidDisplayQ.length >0){
                var view = this._invalidDisplayQ.shift();
                view._validateDisplay();
            }
            this._validatingDisplay = false;

             if (formBridge && xfalib.globals.highlight)   // highLight newly added fields
                $(formBridge).trigger("xfaLayoutComplete");
        },

        createLayout : function(view){
            var options = {target:view} ;
            if(view instanceof xfalib.view.RootSubformView)
                return new xfalib.view.layout.RootSubformLayout(options);
            else if(view instanceof xfalib.view.PageView )
                return new xfalib.view.layout.StaticLayout(options);
            else if(view instanceof xfalib.view.ContentAreaView)
                return new xfalib.view.layout.TopBottomLayout(options);
            else if(view instanceof xfalib.view.SubformSetView)
                return new xfalib.view.layout.SubformSetLayout(options);
            else if(view.el.nodeName == "TR")
                return new xfalib.view.layout.DataTableRowLayout(options);

            var layout = null;
            switch (view.layoutModel.layout)
            {
                case xfalib.view.LayoutConst.LAYOUT_LEFTRIGHTTOPBOTTOM:
                    layout = new xfalib.view.layout.LeftRightLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTTOPBOTTOM:
                    layout = new xfalib.view.layout.RightLeftLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_TOPBOTTOM:
                    layout = new xfalib.view.layout.TopBottomLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_TABLE:
                    layout = new xfalib.view.layout.TableLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_ROW:
                    layout = new xfalib.view.layout.RowLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW:
                    layout = new xfalib.view.layout.RightLeftRowLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_DATATABLE:
                    layout = new xfalib.view.layout.DataTableLayout(options);
                    break;
                default :
                    layout = new xfalib.view.layout.PositionLayout(options);
            }
            return layout;
        },

        isPendingValidateSize : function(view){
            return (this._invalidSizeQ.indexOf(view)  > -1);
        },

        _xfaViewRegistry : function() {
            return window.xfaViewRegistry;    //TODO: remove window dependency
        },
        /*
         * Checks whether any view has any kind of layout activity pending either in measure or update phase.
         */
        isLayoutCycleComplete : function(){
            return !(this._invalidSizeQ.length  > 0 || this._invalidDisplayQ.length > 0);
        }

    })
})(_, $, xfalib);

(function(_, $, xfalib){
    xfalib.view.XfaViewEvent = {
        PRESENCE_CHANGE : "presenceChange",
        EXTENT_CHANGE : "extentChange"
    }
})(_, $, xfalib);

(function(_, $, xfalib){
    xfalib.view.ObjectView = xfalib.ut.EventClass.extend({


        initialize : function(){
            xfalib.ut.EventClass.prototype.initialize.apply(this, arguments);
            this.id = this.options.id;
            this.$el = (this.options.el instanceof $) ? this.options.el : $(this.options.el);
            this.el = this.$el[0];
            this._layoutManager = this._xfaViewRegistry().layoutManager();
        },

        // jQuery delegate for element lookup, scoped to DOM elements within the
        // current view. This should be prefered to global lookups where possible.
        $: function(selector) {
            return this.$el.find(selector);
        },

        _formDomRoot : function() {
            return xfalib.script.Xfa.Instance; //TODO: Remove singleton dependency
        },

        _bind : function(context, func) {
            return function() {
                return func.apply(context, arguments);
            }
        },

        _xfaViewRegistry : function() {
            return window.xfaViewRegistry;    //TODO: remove window dependency
        },

        _mm2px : function(mmSize){
            return xfalib.view.util.Styles._mm2px(mmSize);
        },

        _convertToPx : function(size){
            return xfalib.view.util.Styles._convertToPx(size);
        },

        getOrElse : xfalib.ut.Class.prototype.getOrElse, //short cut but really needed to avoid duplicate code. May be better way next time.

        jqId: xfalib.ut.XfaUtil.prototype.jqId,

        matchJsonType: xfalib.ut.XfaUtil.prototype.matchJsonType,

        $data : xfalib.ut.XfaUtil.prototype.$data,

        $css : xfalib.ut.XfaUtil.prototype.$css

    });

})(_, $, xfalib);
(function(_, $, xfalib){
    var BaseView = xfalib.view.BaseView =  xfalib.view.ObjectView.extend({

        initialize : function() {
            xfalib.view.ObjectView.prototype.initialize.apply(this, arguments);
            this._id = this.el.id;
            this._initialized = false;
            this.parentView = this.options.parentView;
            this.tableCellIndex = this.options.tableCellIndex || 0;
            this.effectiveCellIndex = 0;
            this.model = null;
            this.layoutModel = null;
            this._invalidSizeFlag = true;
            this._invalidDisplayFlag = true;
            this._resizable = false;
            this.edgePresence = true;
            this.$data(this.el, "xfaView", this);
            if(this._id)
                this.model = this._formDomRoot()._xfaTemplateCache.getModel(this._id);
            if(this.model){
                this.createBorder();
                if(this.model.presence == "visible") {
                    this._initialized = true;
                } else {
                    var that = this;
                    var initHandler = {
                        handleEvent: function(evnt) {
                            if(evnt._property == "presence" && !that._initialized){
                                that._initLayout();
                                if(that._initialized){
                                    that.model.off(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, initHandler);
                                }
                            } else if(that._initialized){
                                //The only case when initHandler can be called even if it's initialized is in case of server side scripts which change presence on server.
                                //but does not call initHandler at that time. So we need to remove initHandler explicitly in next call.
                                that.model.off(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, initHandler);
                            }
                        }
                    };
                    this.model.on(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, initHandler);
                }
                this.model.on(xfalib.script.XfaModelEvent.DOM_CHANGED, this);


            }

        },

        createBorder : function(){
            var border = this.model.getElement("border",0,true),
                fill,
                color,
                edge;
            if(border){
                if((fill = border.getElement("fill",0,true)) && (color = fill.getElement("color",0,true))
                    && fill.presence!="hidden"
                    && fill.presence !="invisible"
                    ) {
                    color = color.value;
                    if(color == "")
                        color="255,255,255";     // if no color value is specified then fill default color
                    color = "rgb(" + color + ")";
                    $(this.el).css("background-color", color);
                }

                var allEdgeHidden = true,
                index = 0,
                edge;
                while(edge = border.getElement("edge",index,true)) {
                    if(edge.presence!="hidden" &&  edge.presence!="invisible") {
                        allEdgeHidden = false;
                        break;
                    }
                    index++;
                }
                if(border.presence == "visible"
                    && !allEdgeHidden) {
                    var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(border);
                    if(cssStyleObj){
                        this.$css(this.el, cssStyleObj);
                        return;
                    }

                } else {
                    // LC-3910380 : In case border presence or edge presence is invisible or hidden then marking border as none
                    if(border.presence=="hidden"
                        || border.presence=="invisible"
                        || allEdgeHidden){
                            $(this.el).css("border", "none");
                    }
                }
            }
            this.edgePresence = false;
        },

        //generic function to compute css style from the <font> & <para> element of the model
        _getTextStyle : function(referenceModel) {
            var cssStyleObj={};
            var asparaStylesObj = {};

            var fontElement = referenceModel.getElement('font',0,true);
            if(fontElement) {
                cssStyleObj['font-family'] = fontElement.getAttribute('typeface');
                cssStyleObj['font-size']   = this._convertToPx(fontElement.getAttribute('size'));
                cssStyleObj['font-style']  = fontElement.getAttribute('posture');
                cssStyleObj['font-weight'] = fontElement.getAttribute('weight');
                cssStyleObj['text-decoration'] = fontElement.getAttribute('underline') != 0 ? 'underline' : undefined;

                var fill = fontElement.getElement('fill',0,true);
                if(fill) {
                    var color = fill.getElement('color',0,true);
                    var colorValue = color.value;
                    if(colorValue) {
                        cssStyleObj['color'] = 'rgb('+colorValue+')';
                    }
                }
            }

            var para = referenceModel.getElement('para',0,true);
            if(para) {
                if(para.hAlign)  {
                    asparaStylesObj['right']= this._convertToPx(para.marginRight);
                    asparaStylesObj['left']= this._convertToPx(para.marginLeft);
                    asparaStylesObj['overflow']= "hidden";
                    switch(para.hAlign) {
                        case "right":
                            asparaStylesObj['text-align']= "right";
                            break;
                        case "left":
                        case "radix":  //Till now radix is not implemented, it is mapped to the default one i.e left
                            asparaStylesObj['text-align']= "left";
                            break;
                        case "center":
                            asparaStylesObj['text-align']= "center";
                            break;
                        case "justify":
                        case "justifyAll":
                            asparaStylesObj['text-align']= "justify";
                            break;
                    }
                }
                switch(para.vAlign) {
                   case "top":
                       asparaStylesObj['top']= this._convertToPx(para.spaceAbove);
                       break;
                   case "bottom":
                       asparaStylesObj['bottom']= this._convertToPx(para.spaceBelow);
                       break;
                }
                asparaStylesObj['text-indent'] = this._convertToPx(para.textIndent);
            }
            return {fontStyles : cssStyleObj, paraStyles :  asparaStylesObj};
        },

        _convertXFARichToHtml: function(text){
            var value;
            if(text != null)  {
             if(typeof text == 'string' && text[0] != '<') {
                 text = "<span>"+text+"</span>";   // $.replaceWith expects a HTML string
             }

             //--conversion to jQuery obj to handle font-size of span
             var spanText = $(text);
             spanText.find("*").each(function(index, span){
                  if(span.style) {
                      if(span.style.fontSize) {
                        value= xfalib.view.util.Styles._convertToPx(span.style.fontSize)+"px";
                        span.style['font-size'] = span.style.fontSize = value;
                   }
                }
             });

             text= "<span>"+spanText.html()+"</span>";
           }
           return text;
        },

        _initAccessibilityInfo: function() {
            //accessibility info

            if(this.layoutModel.colspan > 1) {
                this.$el.attr("colspan", this.layoutModel.colspan);
            }
            if(this.layoutModel.rowspan > 1) {
                this.$el.attr("rowspan", this.layoutModel.rowspan);
            }

            // TODO - move these table related stuff to table view
            //The below roles are not conflicting with the native accessibility support introduced in DataTables, but
            //not recommended until scripted data element is used (Refer to: http://www.w3.org/TR/aria-in-html/).
            //With the introduction of row-span and row header - the current info is not complete for ARIA-Roles
            //So if native HTML table is being used for render (DataTableLayout, do not add the ARIA-Roles below).
            // - No change required for table as layout for DataTable is  DATA_LAYOUT_TABLE
            // - Do not add accessibility for 'columnheader' or 'gridcell' if node is TH or TR (the check will also avoid the inefficient check)
            // - Do not add the accessibility for 'row' if node is TR
            var nodeName = this.el.nodeName;
            var partOfNativeTable = (nodeName == "TABLE"
                                    || nodeName == "TR"
                                    || nodeName == "TD"
                                    || nodeName == "TH");

            if(!partOfNativeTable) {
                if (this.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_TABLE) {
                    //put grid role
                    this.$el.attr("role", "grid");
                }
                else if (this._isTableHeaderCell()) {
                    this.$el.attr("role", "columnheader");
                }
                else if (this._isTableCell()) {
                    this.$el.attr("role", "gridcell");
                }
                else if (this.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW) {
                    this.$el.attr("role", "row");
                }
                else if (this.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) {
                    this.$el.attr("role", "row");
                }
            }
            //add role and title to this.$el
            var assist = this.model.getElement("assist", 0, true);
            if(assist && assist.role) {
                //translate XFA roles to HTML5 roles (WAria roles)
                if(assist.role == 'TR' && !partOfNativeTable)
                    this.$el.attr("role", "row");
                else if(assist.role == 'TH'){
                    //do nothing as header info is to be propagated to individual cells
                    //this.$el.attr("role", "row");
                }
                else if(assist.role == 'TF'){
                    //do nothing as header info is to be propagated to individual cells
                    //this.$el.attr("role", "row");
                }
                else if(!partOfNativeTable) {
                    // list role needs to be used for a div with list of items and listitem role for its children.
                    if(assist.role == 'UL') {
                        this.$el.attr("role", "list");
                    } else if(assist.role == "LI") {
                        this.$el.attr("role", "listitem");
                    } else {
                        this.$el.attr("role", assist.role);
                    }
                }
            }

            if (nodeName === "TABLE") {
                this.$el.attr("aria-label", this._getScreenReaderText());
            }

            //add lang parameter
            var lang = this._langFromLocale(this.model.jsonModel.locale);
            if(lang && lang.length > 0){
                this.$el.attr("lang", lang);
            }

            this._assignToolTip();
        },

        _assignToolTip : function () {
        },

        _getScreenReaderText: function(){
        },

        /**
         *
         * @param i
         * @param val
         * @return {String}
         * @private used by XfaDrawView and FieldView
         */
        _adjustTextCoordinate: function(i, val){
            //somehow jquery attr() function cannot read textLength attribute
            var sTextLen = this.getAttribute('textLength');
            if(sTextLen && val && val.length > 2) {
                //remove px
                var textLen = Number(sTextLen.substr(0, sTextLen.length-2));
                var x = Number(val.substr(0, val.length-2));
                //server adjust x for all rtl text content so we need to revert it back for webkit
                x += textLen;
                return x+"px";
            }
        },

        /**
         *
         * @private
         * internal function to extract lang from locale
         */
        _langFromLocale : function(locale) {
            var lang;
            if(locale && locale.length > 0) {
                //locale can be in the form of country_LANG -- en_US
                //Whereas lang attribute of html expects only country code
                var index = locale.indexOf('_');

                if(index != -1){
                    lang = locale.substr(0, index);
                }
                else {
                    lang = locale;
                }

                //leap of faith that lang would be ISO 631 complaint.
            }
            return lang;
        },

        setElement: function(element) {
          this.undelegateEvents();
          this._setElement(element);
          this.delegateEvents();
          return this;
        },

        _setElement: function(el) {
          this.$el = el instanceof $ ? el : $(el);
          this.el = this.$el[0];
        },


        delegateEvents: function(events) {
          var delegateEventSplitter = /^(\S+)\s*(.*)$/;
          events || (events = _.result(this, 'events'));
          if (!events) return this;
          this.undelegateEvents();
          for (var key in events) {
            var method = events[key];
            if (!_.isFunction(method)) method = this[method];
            if (!method) continue;
            var match = key.match(delegateEventSplitter);
            this.delegate(match[1], match[2], _.bind(method, this));
          }
          return this;
        },

        delegate: function(eventName, selector, listener) {
          this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);
          return this;
        },

        undelegateEvents: function() {
          if (this.$el) this.$el.off('.delegateEvents' + this.cid);
          return this;
        },

        _initLayout : function(){
            var presence = this.model ? this.model.presence : "visible";

            if(!this.layoutModel){
                //If layoutmodel has not been initialized, initialize that.
                this._initializeLayoutModel();
            }

            if(this._isPlaceHolderEl() && (presence == "visible" || presence == "invisible")){
                // Currently we are on a placeholder div el (because this element was hidden or inactive). It's time to find the actual element.
                var templateId = (this.model ? this.model._templateId() : this._id) || this._id;
                var actualEl = this._xfaViewRegistry().templateCache().get(templateId, true);
                if(actualEl){
                    // hides the actualEL as the layout is still disturbed, removes the hideElement class on updateDisplay
                    $(actualEl).addClass("hideElement");
                    this.$el.replaceWith(actualEl);
                    this.setElement(actualEl);
                    this.$data(this.el, "xfaView", this);
                    this._initializeLayoutModel(); //need to re-initialize layout model at this point.
                }
                else
                    xfalib.runtime.xfa.Logger.error("xfaView", "Html template could not be found. id:"+this._id+", som:"+this.getOrElse(this.model, "somExpression"));
            }

            if(presence == "visible"){
                var nodeName = "";
                if(this.model){
                    this.model.on(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this);
                    this._initAccessibilityInfo();
                    nodeName = this.model.getAttribute("name");
                }
                // as part of html size reduction, server stopped sending node type and name of the component
                // add classes for the same
                var nodeType = (xfalib.ut.XfaUtil.prototype.$data(this.el, xfalib.view.LayoutConst.XFA_MODEL) ||{})[xfalib.view.LayoutConst.NODE_TYPE];
                if(nodeType)
                    this.$el.addClass(nodeType);
                if(nodeName != null && nodeName.length > 0) {
                    this.$el.addClass(nodeName);
                }
                var extent = this._computeExtent();
                this.$css(this.el, extent);
                this._initialized = true;
            } else{
                //If presence is set to visible then _handlePresenceChange is called as part of sync from subclasses
                // But otherwise we need to explicitlly call _handlePresenceChange here.
                this._handlePresenceChange({newText : presence});
            }
        },

        handleEvent: function(evnt) {
            switch(evnt.name) {
                case xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED:
                    this.handleModelChanged(evnt);
                    break;
                case xfalib.script.XfaModelEvent.DOM_CHANGED:
                    this.handleDomChanged(evnt);
                    break;
                default:
                    /* log an error message */
            }
        },

        handleDomChanged : function(event){
            switch(event._property) {
                case "font.fill.color.value":
                    this._handleFontFillColorValue(event);
                    break;
                case "border.fill.color.value":
                case "textEdit.border.fill.color.value":
                case "numericEdit.border.fill.color.value":
                case "imageEdit.border.fill.color.value":
                case "signature.border.fill.color.value":
                case "dateTimeEdit.border.fill.color.value":
                case "passwordEdit.border.fill.color.value":
                case "choiceList.border.fill.color.value":
                    this._handleBorderFillColorValue(event);
                    break;
                case "border.edge.presence":
                    this._handleBorderEdgePresence(event);
                    break;
                case "border.edge.color.value":
                    this._handleBorderChange(event);
                    break;
                case "border.edge.thickness":
                    this._handleBorderChange(event);
                    break;
                case "border.fill.presence":
                    this._handleBorderFillPresence(event);
                    break;
                case "topInset":
                    this._handleTopInset(event);
                    break;
                case "bottomInset":
                    this._handleBottomInset(event);
                    break;
                case "leftInset":
                    this._handleLeftInset(event);
                    break;
                case "rightInset":
                    this._handleRightInset(event);
                    break;
            }
        },

        handleModelChanged : function(event) {
            if (event._property == "presence") {
                this._handlePresenceChange(event);
            } else if (event._property == "access") {
                this._handleAccessChange(event);
            }else if (event._property == "relevant")  {
                this._handleRelevantChange(event);
            }
        },

        _handleRelevantChange : function(event) {
//				xfa.Logger.debug("[_handlePresenceChange]presence:som"
//						+ event.newText + ":" + this.$el.data("som"));
            switch (event.newText) {
                case "+print":
                case "print" :
                    if(this.model.getAttribute("presence") == "visible")
                        this.el.style.visibility = "hidden" ;
                    break;
                case "-print":
                    if(this.model.getAttribute("presence") == "visible")
                        this.el.style.visibility = "visible";
                    break;
                default:
                    break;
            }
            this.parentView.invalidateSize();
        },

        _handlePresenceChange : function(event) {
//				xfa.Logger.debug("[_handlePresenceChange]presence:som"
//						+ event.newText + ":" + this.$el.data("som"));
            switch (event.newText) {
            case "visible":
                if(this.model.getAttribute("relevant") == "print" || this.model.getAttribute("relevant") == "+print")
                    this.el.style.visibility = "hidden" ;
                else this.el.style.visibility= "inherit";
                break;
            case "invisible":
            case "hidden":
            case "inactive":
                this.el.style.visibility = "hidden";
                break;
            default:
                this.el.style.visibility= "inherit";
                break;
            }
            /*
             FORMS-11363 : fix for height calculation of table cell
             Enable this toggle for old behaviour (if any regression comes)
             */
            if ((window.FD && window.FD.isToggleEnabled("FT_FORMS-11363")) && xfalib.runtime.xfa.form.mbInitialized) {
                this.parentView.invalidateSize();
            } else {
                this.parentView.invalidateSize();
            }

        },

        _handleRightInset : function(event) {
        },

        _handleBottomInset : function(event) {
            /*var bottomInset = parseFloat(event.prevText) ;
             if(bottomInset)  {
             var extent = this._computeExtent();
             extent["margin-bottom"] =  this._mm2px(25.4* bottomInset) ;
             this.layoutModel.marginbottom = extent["margin-bottom"];
             this._invalidDisplayFlag = true;
             this._validateDisplay();
             var a= this.measureSize();
             this.$css(this.el, extent);
             } */

        },

        _handleLeftInset : function(event) {
        },

        _handleTopInset : function(event) {
        },

        _handleFontFillColorValue : function(event) {

        },

        _handleBorderFillColorValue : function(event) {
            var borderFillColorValue = event.prevText;
            var visibility =  this.model.border.fill.presence ;

            if(borderFillColorValue && visibility != "invisible" && visibility != "hidden")  {
                if(borderFillColorValue.indexOf("rgb") == -1)
                    borderFillColorValue = "rgb(" + borderFillColorValue + ")";

                if (_.contains(["textEdit","numericEdit","imageEdit","signature","dateTimeEdit","choiceList",
                        "passwordEdit"], event._property.substring(0,event._property.indexOf('.')))) {
                    $(this.widget).css("background-color", borderFillColorValue);
                } else if( event._property === "border.fill.color.value") {
                    $(this.el).css("background-color", borderFillColorValue);
                }
            }
        },

        _handleBorderEdgePresence : function(event) {
            var visibility = event.prevText;
            var defaultBorder = "1px solid rgb(0, 0, 0)"
            if(visibility == "hidden" || visibility == "invisible") {
                $(this.el).css("border", "none");
            }
            else {
                var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(this.model.border);
                if(cssStyleObj)
                    this.$css(this.el, cssStyleObj);
                else $(this.el).css("border", defaultBorder);
            }


        },

        _handleBorderChange : function(event) {
            var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(this.model.border);
            if(cssStyleObj)
                this.$css(this.el, cssStyleObj);
        },

        _handleBorderFillPresence : function(event) {
            var borderFillPresence = event.prevText;
            var color = this.model.border.fill.color.value;
            if(borderFillPresence == "hidden" || borderFillPresence == "invisible"){
                $(this.el).css("background-color", "rgb(255,255,255)" )
            }
            else {
                if(color.indexOf("rgb") == -1)
                    color = "rgb(" + color + ")";
                $(this.el).css("background-color", color);
            }
        },

        _fillColor : function(color) {
            $(this.el).css("background-color", color)
        },

        _borderColor : function(color) {
            $(this.el).css("borderColor", color)
        },

        _handleAccessChange : function(event) {

        },

        /*
         * This method calls _initLayout in addition to calling original _syncFormToHtml.
         * This is specially useful when using server side scripts and calls deep sync.
         * If you are sure that object has been initialized call _syncFormToHtml else call this method.
         * Other objects(other than *this*) should always call this method insteadOf internal _syncFormToHtml method.
         */
        syncFormNodeToHtml: function(deepSync){
            if(!this._initialized && this._isPlaceHolderEl()){
                //If this is uninitialized placeHolderEl(in case presence is hidden initially and has not been changed since
                // then we want to attempt an _initLayout to check if presence needs to be handled.
                this._initLayout();
                if(!this._initialized && this._isPlaceHolderEl()){
                    //If this is still placeHolderEl then no point of running a sync
                    return;
                }
            }
            this._syncFormNodeToHtml(deepSync);
        },

        _syncFormNodeToHtml : function(deepSync) {
            // TODO : make sync logic better
            if (this.model) {
                this._handlePresenceChange({newText:this.model.presence})  ;
                //this._handleAccessChange({newText:this.model.mEffAccess})      ;
            }
            this.invalidateSize();
        },

        _initializeLayoutModel : function() {
            //In order to minimize the size of html generated, this layoutmodel is generated in a cryptic way
            //here is the mapping between the cryptic variables and explanatory variables.
            //in the interest of readability, preserving the good readable names

            var lm = this.getOrElse(this.$data(this.el, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL, {})
            var layout = {};
            if(this instanceof xfalib.view.ContainerView && !lm.hasOwnProperty(xfalib.view.LayoutConst.SUBFORM_LAYOUT)){
                layout.layout = "position";
            }
            else if(lm.hasOwnProperty(xfalib.view.LayoutConst.SUBFORM_LAYOUT)) {
                layout.layout = lm[xfalib.view.LayoutConst.SUBFORM_LAYOUT]
            }

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_X))
                layout.extentx = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_X]);
            else
                layout.extentx = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_Y))
                layout.extenty = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_Y]);
            else
                layout.extenty = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_MIN_W))
                layout.extentminw = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_MIN_W]);
            else
                layout.extentminw = -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_MIN_H))
                layout.extentminh = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_MIN_H]);
            else
                layout.extentminh = -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_MAX_W))
                layout.extentmaxw = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_MAX_W]);
            else
                layout.extentmaxw = -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_MAX_H))
                layout.extentmaxh = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_MAX_H]);
            else
                layout.extentmaxh = -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_W))
                layout.extentw = Math.max(this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_W]), layout.extentminw);
            else
                layout.extentw =  Math.max(0, layout.extentminw);

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_H))
                layout.extenth = Math.max(this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_H]), layout.extentminh);
            else
                layout.extenth =  Math.max(0, layout.extentminh);

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_ACTUAL_W))
                layout.extentactualw = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_ACTUAL_W]);
            else
                layout.extentactualw =  -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_ACTUAL_H))
                layout.extentactualh = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_ACTUAL_H]);
            else
                layout.extentactualh =  -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.MARGIN_TOP))
                layout.margintop = this._mm2px(lm[xfalib.view.LayoutConst.MARGIN_TOP]);
            else
                layout.margintop = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.MARGIN_RIGHT))
                layout.marginright = this._mm2px(lm[xfalib.view.LayoutConst.MARGIN_RIGHT]);
            else
                layout.marginright = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.MARGIN_BOTTOM))
                layout.marginbottom = this._mm2px(lm[xfalib.view.LayoutConst.MARGIN_BOTTOM]);
            else
                layout.marginbottom = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.MARGIN_LEFT))
                layout.marginleft = this._mm2px(lm[xfalib.view.LayoutConst.MARGIN_LEFT]);
            else
                layout.marginleft = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.BORDER_TOP))
                layout.bordertop = this._mm2px(lm[xfalib.view.LayoutConst.BORDER_TOP]);
            else
                layout.bordertop = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.BORDER_RIGHT))
                layout.borderright = this._mm2px(lm[xfalib.view.LayoutConst.BORDER_RIGHT]);
            else
                layout.borderright = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.BORDER_BOTTOM))
                layout.borderbottom = this._mm2px(lm[xfalib.view.LayoutConst.BORDER_BOTTOM]);
            else
                layout.borderbottom = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.BORDER_LEFT))
                layout.borderleft = this._mm2px(lm[xfalib.view.LayoutConst.BORDER_LEFT]);
            else
                layout.borderleft = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.COL_SPAN))
                layout.colspan = +lm[xfalib.view.LayoutConst.COL_SPAN];
            else
                layout.colspan = 1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.ROW_SPAN))
                layout.rowspan = +lm[xfalib.view.LayoutConst.ROW_SPAN];
            else
                layout.rowspan = 1;

            if(lm.hasOwnProperty(xfalib.view.LayoutConst.COLUMN_WIDTHS)){
                var colWidths = lm[xfalib.view.LayoutConst.COLUMN_WIDTHS].split(" ");
                var calcWidths = _.map(colWidths,
                    function(colWidth){
                        return this._mm2px(colWidth);
                    },
                    this);
                layout.columnwidths = calcWidths;
            }

            if(this._isTableCell()){
                var columnWidth = -1;
                var tableLayoutModel = this.parentView.parentView.layoutModel;
                if(tableLayoutModel.columnwidths && tableLayoutModel.columnwidths.length >= this.tableCellIndex)
                    columnWidth = tableLayoutModel.columnwidths[this.tableCellIndex];
                if(columnWidth >= 0){
                    layout.extentw = columnWidth;
                    layout.extentactualw = columnWidth;
                    layout.extentminw = 0;
                    layout.extentmaxw = "none";
                }
            }
            layout.initialh = layout.extenth;
            layout.initialw = layout.extentw;

            if(lm.hasOwnProperty(xfalib.view.LayoutConst.CAP_PLACEMENT))
                layout.captionPlacement = lm[xfalib.view.LayoutConst.CAP_PLACEMENT];

            if(lm.hasOwnProperty(xfalib.view.LayoutConst.PAGE_NUMBER))
                layout.pageNumber = lm[xfalib.view.LayoutConst.PAGE_NUMBER];

            this.layoutModel = layout;
            this.resizable = this.layoutModel.extentactualw < 0 ||  this.layoutModel.extentactualh < 0;
        },

        _computeExtent : function() {
            var extent = {} ;
            extent["margin-left"] = this._marginLeft();
            extent["margin-right"] = this._marginRight();
            extent["margin-top"] = this._marginTop();
            extent["margin-bottom"] = this._marginBottom();
            extent["padding-left"] = this._padLeft();
            extent["padding-right"] = this._padRight();
            extent["padding-top"] = this._padTop();
            extent["padding-bottom"] = this._padBottom();
            extent["border-left-width"] = this._subPixelValue(this.layoutModel.borderleft);
            extent["border-right-width"] = this._subPixelValue(this.layoutModel.borderright);
            extent["border-top-width"] = this._subPixelValue(this.layoutModel.bordertop);
            extent["border-bottom-width"] = this._subPixelValue(this.layoutModel.borderbottom);
            extent["-webkit-box-sizing"] = "border-box";
            extent["-moz-box-sizing"] = "border-box";
            extent["box-sizing"] = "border-box";
            extent["position"] = "absolute";
            return extent;
        },

        _padLeft : function() {
            return this.layoutModel.marginleft
                    - this.layoutModel.borderleft / 2;
        },

        _padRight : function() {
            return this.layoutModel.marginright
                    - this.layoutModel.borderright / 2;
        },

        _padTop : function() {
            return this.layoutModel.margintop - this.layoutModel.bordertop / 2;
        },

        _padBottom : function() {
            return this.layoutModel.marginbottom
                    - this.layoutModel.borderbottom / 2;
        },

        _marginLeft : function() {
            return -this.layoutModel.borderleft / 2;
        },

        _marginRight : function() {
            return -this.layoutModel.borderright / 2;
        },

        _marginTop : function() {
            return -this.layoutModel.bordertop / 2;
        },

        _marginBottom : function() {
            return -this.layoutModel.borderbottom / 2;
        },

        _isTableCell : function(){ //Too long check??? Please shorten it.
            if(this.parentView && this.parentView.layoutModel &&
                (this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW || this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) &&
                this.parentView.parentView && this.parentView.parentView.layoutModel &&
                this.parentView.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_TABLE){
                  return true;
                }
            return false;
        },

        _isTableHeaderCell : function(){ //Too long check??? Please shorten it.
            if(this.parentView && this.parentView.layoutModel &&
                (this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW || this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) &&
                this.parentView.model.getElement("assist", 0, true) && this.parentView.model.assist.role == "TH"){
                return true;
            }
            return false;
        },


        //For a given cell identify if the cell is part of header row (THEAD)
        _isPartOfHeaderRow : function(){
            if(this.parentView && this.parentView.layoutModel &&
                (this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW || this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) &&
                this.parentView.el.parentNode.nodeName == "THEAD"){
                return true;
            }
            return false;
        },

        $computeWH : function(){
            //private method but still overridden in SubformSetView
            var extent = {};
            //If the field is not initialized(invisible or hidden), then there is no need to set w/h for el. This would automatically be done during initialization via sync
            extent["width"] = this.layoutModel.extentw + this.layoutModel.borderleft/2 + this.layoutModel.borderright/2;
            extent["height"] = this.layoutModel.extenth + this.layoutModel.bordertop/2 + this.layoutModel.borderbottom/2 ;
            return extent;
        },

        _isPlaceHolderEl : function(){
            return this.$data(this.el, "xfaHiddenPH");
        },

        //layout related functions
        invalidateSize : function(){
            this._invalidSizeFlag = true;
            this._layoutManager.invalidateSize(this);
            this.invalidateDisplay();
        },

        invalidateDisplay : function(){
            this._invalidDisplayFlag = true;
            this._layoutManager.invalidateDisplay(this);
        },

        _validateSize : function(recursive){
            if(this._invalidSizeFlag){
                if(this._initialized){
                    var sizeChanged = this.measureSize();
                    if(sizeChanged)
                       this.parentView.invalidateSize();
                }
                this._invalidSizeFlag = false;
            }
        },

        _validateDisplay : function(recursive){
            if(this._invalidDisplayFlag){
                if(this._initialized){
                    this.updateDisplay();
                    this.trigger("layoutComplete");
                }
                this._invalidDisplayFlag = false;
            }
        },

        measureSize : function(){
            var changed = false;
            if(!this.resizable){
                if(this.layoutModel.extenth != this.layoutModel.initialh){
                    this.layoutModel.extenth = this.layoutModel.initialh;
                    changed = true;
                }
                if(this.layoutModel.extentw != this.layoutModel.initialw){
                    this.layoutModel.extentw = this.layoutModel.initialw;
                    changed = true;
                }
            }
            return changed;
        },

        updateDisplay : function(){
            var extent = this.$computeWH();
            this.$css(this.el, extent);
            $(this.el).removeClass("hideElement");
        },

        _subPixelValue : function(value){
            if(value > 0.01)
                return Math.max(value, 1.0);
            else
                return value;
        },

        /*
         * Return the page number containing this view.
         * Note: page number starts with 1 instead of 0
         */
        _pageNumber : function(){
            //Page number is passed as argument to createView and is available in options
            return this.getOrElse(this, "options.pageNumber", -1);
        },

        /*
         * @function
         * Focuses the widget of the provided view.
         * @param {Object} view : view whose widget needs to be focussed.
         */
        _focusWidget : function (view) {
            var jqWidget = view.jqWidget;
            if (!jqWidget) {
                return;
            }
            if(xfalib.ut.XfaUtil.prototype._isIpad()) {
                var offset = jqWidget.$userControl.offset(),
                    top = offset.top,
                    left = offset.left;
                window.scrollTo(left,top) ;
            }
            jqWidget.focus();
        }

    });

    Object.defineProperty(BaseView.prototype, "resizable", {
        get : function(){
            return this._resizable;
        },

        set : function(sValue){
            this._resizable = sValue;
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.XfaDrawView = xfalib.view.BaseView.extend({
        $drawChild : null,

        initialize : function(){
            xfalib.view.BaseView.prototype.initialize.apply(this, arguments);
            this._initLayout();
            this._createAccessibilityInfo();
        },

        handleModelChanged : function(event) {
            switch(event._property) {
                case "rawValue" :
                                if(event.jsonModel.newText) {
                                    this._updateView(event.jsonModel.newText);
                                }
                                break;
                default:
                    xfalib.view.BaseView.prototype.handleModelChanged.apply(this,
                        arguments);
            }
        },

        handleDomChanged : function(event) {
             switch(event._property) {
                 case "value.text" :
                 case "value.exData" :
                                    if(event.jsonModel.newText) {
                                        this._updateView(event.jsonModel.newText);
                                    }
                                    break;
                 case "h" ://--we support computation only on line for now.
                                 if(this.getOrElse(this.model, "value.oneOfChild.className", "") === "line"){
                                     this._computeLineHeight();
                                 }
                                 break;
                 default:
                     xfalib.view.BaseView.prototype.handleDomChanged.apply(this,
                          arguments);
            }
        },

        _handleFontFillColorValue : function(event) {
            if(this.model && this.model.value) {
                var content = this.model.value.oneOfChild;
                var htmlText = content.jsonModel._value;
                if(content.getAttribute('contentType') == 'text/html') {
                    var $internalHTML = $('<span>'+htmlText+'</span>');
                    //change the top level element to span to wrap up all the <p>, because it will cause unnecessary paragraph break
                    //add 'display:inline' style
                    //no null check because jQuery is cool!
                    //ToDo: change all your paragraphs into <span> and add a <br> element between them
                    //this will work for few cases where there is one single paragraph in the text or plain text cases.
                    $internalHTML.find("p").eq(0).css('display','inline');
                    this._updateView($internalHTML[0]);
                }
                else
                    this._updateView(htmlText);
            }
            //now check the rawValue and update view based on that rawValue

        },

        _updateView : function(text) {
              if (this._initialized && this.model) {
                  var value = this.model.getElement('value',0, true);
                  if(value) {
                      var  child = value.oneOfChild;
                      if (["text","exData"].indexOf(child.className) !== -1) {
                          var cssObj = this._getTextStyle(this.model);
                          if (cssObj)
                              this.$css(this.el, cssObj.fontStyles);

                          text = xfalib.ut.XfaUtil.prototype.encodeScriptableTags(this._convertXFARichToHtml(text));
                          this.$el.children().replaceWith(text);
                          if (this.el.children[0] && cssObj) {
                              this.$css(this.el.children[0], cssObj.paraStyles);
                          }
                      }
                      else if (child.className === 'image' && text) {//if draw is of type image
                          this.$el.children()[0].setAttribute('src', 'data:;base64,' + text);
                      }

                      if(this.resizable){
                          this.invalidateSize();
                      }
                  }
            }
        },

        measureSize : function(){
            var resized = false,
                text = null,
                content = this.getOrElse(this, "model.value.oneOfChild", null);

            // check to resize draw only in case of floating field and is resizable
            if(this.resizable && this._isFloatingFieldPresent(content)){
                // if content is rich text, then use jquery html() to support rich text element else text()
                if(content && content.getAttribute('contentType') == 'text/html') {
                    text = this.$el.html();
                } else {
                    text = this.$el.text();
                }
                resized = xfalib.view.FieldView.prototype._updateWidgetModel.call(this, text);
            }
            return resized;
        },

        _getMeasurementOptions : function(){
           var measureOptions = xfalib.view.FieldView.prototype._getMeasurementOptions.apply(this, arguments),
               content = this.getOrElse(this, "model.value.oneOfChild", null);
           return $.extend({}, measureOptions, {
               contentType : content ? content.getAttribute('contentType') : "",
               isDraw : true,
               refEl : this.el
           });

        },
        /**
         * @function
         * Utility function to checks whether the draw is having floating field or not
         * @param {object} content : contains jsonValue , _origTmpltVal etc.
         * @returns {boolean} : true if draw contains floating field else false
         */
        _isFloatingFieldPresent : function (content) {
            if (content && content._origTmpltVal) {
                var $internalHTML = $('<span>' + content._origTmpltVal + '</span>');
                return $internalHTML.find('[xfa\\:embed]').length > 0;
            }
            return false;
        },

        _syncFormNodeToHtml : function(val) {
            //in order to save some bytes
            // we don't send xmlns attributes from server so set it here
            var children = this.$el.children(),
                value = null;
            if(children.length)
            {
                if (children[0].tagName === 'svg')
                {
                        // In case of kerning, we add letterSpacing in XDP. View generated contains spaced letters which are read separately
                        // by the screen readers, to avoid this we are checking if it contains letterSpacing, if yes then add aria-label
                        // on top level and hide nested elements from screen reader.
                        if(this.model && this.model.jsonModel && this.model.jsonModel.children){
                            for (var i = 0; i < this.model.jsonModel.children.length; i++) {
                                if(this.model.jsonModel.children[i]._class==="font"){
                                    if(this.model.jsonModel.children[i].letterSpacing){
                                        this.el.setAttribute('aria-label', this.model.rawValue);
                                        children[0].setAttribute('aria-hidden', 'true');
                                    }
                                    break;
                                }
                            }
                        }
                    children[0].setAttribute('role','presentation'); // CQ-4274732 : To prevent svg being read out as graphic
                    children[0].setAttribute('xmlns', 'http://www.w3.org/2000/svg');
                    children[0].setAttribute('xmlns:xlink', 'http://www.w3.org/1999/xlink');
                    children[0].setAttribute('focusable', 'false'); //LC-7105 LC-5444 svg tabIndex doesn't work so adding focusable as false
                    //Required so that draw do not spill out of their parent div.
                    var cssExtent = {};
                    cssExtent["width"] = "100%";
                    cssExtent["height"]= "100%";
                    this.$css(children[0], cssExtent);
                    if(this.getOrElse(this.model, "value.oneOfChild.className", "") === 'line'){
                       var pxHeight = xfalib.view.util.Styles._convertToPx(this.model.h);
                       var svgHeight = xfalib.view.util.Styles._convertToPx(children[0].getAttribute('height'));
                       if(svgHeight && pxHeight != svgHeight) {
                           this._computeLineHeight();
                       }
                    }
                }
            }

            if(this.model){
                value = this.model.getElement('value',0, true);
            }
            if(value) {
                var  child = value.oneOfChild;
                if (child._modelChanged === true) { //no need to check it here as updateview checks it anyway
                    var jsonVal = child.jsonValue || child.value; // call to child.value will use typedVal and strip off html tags : LC-5427
                    if (child.className === "image" && jsonVal == null) {
                        //for images, if the value is undefined or null return the href attribute
                        jsonVal = child.href;
                    }
                    this._updateView(jsonVal);
                } else { //for draw do it for the very first time as well
                    if (child.className === 'image') { //if draw is of type image
                        if (child.value) {
                            this.$el.children()[0].setAttribute('src',
                                'data:;base64,' + child.value);
                        } else {
                            this.$el.children()[0].setAttribute('src', child.href);
                        }
                    }
                }
            }

            xfalib.view.BaseView.prototype._syncFormNodeToHtml.apply(this, arguments);
        },

        _computeLineHeight : function() {   //lc-5463
           //-- computing line height
          var children = this.$el.children();
          var lineNode ={};
          if(children[0]) {
             lineNode = children[0].childNodes[0];
          }
          var pxHeight = xfalib.view.util.Styles._convertToPx(this.model.h);
          if(lineNode) {
             //--transforming the code from other units to pixel and changing its type to Numer for further computation
             var x1 = xfalib.view.util.Styles._convertToPx(lineNode.getAttribute('x1'));
             var x2 = xfalib.view.util.Styles._convertToPx(lineNode.getAttribute('x2'));
             var y1 = xfalib.view.util.Styles._convertToPx(lineNode.getAttribute('y1'));
             var y2 = xfalib.view.util.Styles._convertToPx(lineNode.getAttribute('y2'));

             var slope = (y2-y1)/(x2-x1);
             if(!isFinite(slope)) {
                y2 = y1 +  pxHeight;
                lineNode.setAttribute('y2',String(y2 +'px'));
                children[0].setAttribute('height',String(pxHeight +'px'));
                this.layoutModel.extenth = pxHeight ;
                var cssHeight = {};
                cssHeight['height'] = String(pxHeight +'px');
                this.$css(this.el, cssHeight);
             }
           /*if(slope == 0) {
                x2 = x1 +  pxHeight;
             }
             if(isFinite(slope) && slope != 0) {
                x2 = x1 +  pxHeight * Math.sin(Math.atan(slope)) ;
                y2 = y1 -  pxHeight * Math.cos(Math.atan(slope)) ;
             }*/
            // lineNode.setAttribute('x2',String(x2 +'px'));

          }
        },

        _initLayout : function(){
            xfalib.view.BaseView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                var drawType = this.getOrElse(this.$data(this.el, xfalib.view.LayoutConst.XFA_MODEL)[xfalib.view.LayoutConst.NODE_TYPE], "").toLowerCase();

                if(!$.browser.msie){
                    //All supported browser except IE are not able to gracefully handle 1px svg drawings.
                    // The reason for that, they start draw at grid lines and draw .5px on both sides of gridlines.
                    // Some browsers mix half pixel black with white to produce grey but others may not.
                    // To handle this consistently, we upgrade 1px drawings to 2px for non IE browsers.
                    if(drawType == "line"){
                        this.$('line[stroke-width="1px"]').attr("stroke-width", "2px");
                    }
                    else if(drawType == "rectangle"){
                        this.$('path[stroke-width="1px"]').attr("stroke-width", "2px");
                    }
                }

                if($.browser.webkit || $.browser.chrome || xfalib.ut.Utilities.checkMinMozillaVersion(28)){
                    //chrome handles the rtl text element in a different way.
                    //there is a similar function in FieldView
                    this.$('text[direction="rtl"]').attr('text-anchor', 'end');
                }


                this.$drawChild = $(this._findDrawElement());
                if(drawType == "line"){
                    //For very thin lines less than one pixel, to avoid missing lines, their containing div should be 1px minimum in size
                    if(this.layoutModel.extentw > 0.01 && this.layoutModel.extentw < 1.0)
                        this.layoutModel.extentw  = 1.0;
                    if(this.layoutModel.extenth > 0.01 && this.layoutModel.extenth < 1.0)
                        this.layoutModel.extenth = 1.0;
                }
                if(drawType == "rectangle"){
                    //To avoid missing edges of rectangle, their containing div should be *ceil*ed to next integer. Just heuristic/observation
                    this.layoutModel.extentw = Math.ceil(this.layoutModel.extentw);
                    this.layoutModel.extenth  = Math.ceil(this.layoutModel.extenth);
                }
                this._syncFormNodeToHtml(true);
            }
        },

        _createAccessibilityInfo: function() {
            var screenReaderText = this._getScreenReaderText();
            //add alt for img tags...
            if(screenReaderText && this.$drawChild && this.$drawChild.is("img")){
                this.$drawChild.attr("alt", screenReaderText)
            }
            else if(screenReaderText) {
                $(this).attr("aria-label", screenReaderText)
            }

            // check for heading roles
            var role = this.getOrElse(this.model.getElement("assist"), "role", "");
            if (/^H[1-6]$/.test(role)) {
                this.$el.attr("role", "heading").attr("aria-level", role[1]);
            }
        },

        _assignToolTip: function () {
            var toolTipText = xfalib.ut.XfaUtil.prototype._getToolTipText(this.model);
            if (toolTipText) {
                this.$el.attr("title", toolTipText);
            }
        },

        _getScreenReaderText : function(){
            if (this.model) {
                //find speak priority first ---
                var assist = this.model.getElement("assist", 0, true);
                var screenReaderText;

                var priority = "custom";
                var speak;
                var toolTip;

                if(assist ) {
                    //&& assist.speak && assist.speak.priority
                    speak = assist.getElement("speak", 0, true);
                    toolTip = assist.getElement("toolTip", 0, true);
                    if(speak) {
                        priority = speak.getAttribute('priority');
                    }
                }

                if(priority == "custom") {
                    if(speak) {
                        screenReaderText = speak.value;
                    }
                    else if(toolTip) {
                        screenReaderText = toolTip.value; //LC-6805: tooltip is shown as [Object Object] for text objects
                    }
                    else if(this.model.jsonModel.extras) {
                        screenReaderText = this.model.jsonModel.extras.caption;
                    }
                    else {
                        screenReaderText = this.model.jsonModel.name;
                    }
                }
                else if(priority == "toolTip") {
                    if(toolTip) {
                        screenReaderText = toolTip.value;
                    }
                    else if(this.model.jsonModel.extras) {
                        screenReaderText = this.model.jsonModel.extras.caption;
                    }
                    else {
                        screenReaderText = this.model.jsonModel.name;
                    }
                }
                else if(priority == "name") {
                    screenReaderText = this.model.jsonModel.name;
                }
                 return screenReaderText;

            }
        },

        _computeDrawChildExtent : function(){
            var extent = {};
            var drawType = this.getOrElse(this.$data(this.el, xfalib.view.LayoutConst.XFA_MODEL)[xfalib.view.LayoutConst.NODE_TYPE], "").toLowerCase();
            if(drawType == "text"){
                //This is to avoid truncation of svg text when SVG is larger than containing div.
                //In that case we allow SVG to be large upto extent of 120% of the assigned draw extents
                // Each browser handles svg differently. Below fix works for all supported browser and avoid 20% truncation which would handle most common cases.
                // Actual fix would require exact combined svg height/width calculation probably in XTG side.
                extent["width"] = "120%";
                extent["height"]= "120%";
            } else {
                //Required so that draw do not spill out of their parent div.
                extent["width"] = "100%";
                extent["height"]= "100%";
            }
            return extent;
        },

        _findDrawElement : function(){
            var drawEls = this.$el.children();
            if(drawEls.length >0)
                return drawEls.get(0);
        },

        updateDisplay : function(){
            xfalib.view.BaseView.prototype.updateDisplay.apply(this, arguments);
            if(this.$drawChild != null && !this.$drawChild.is("img")) {
                //only set extent if it is not img as img has its own extent
                var drawChildExtent = this._computeDrawChildExtent();
                //do this only if
                if(this.$drawChild.length)
                    this.$css(this.$drawChild.get(0), drawChildExtent);

            }
        }

    });
})(_, $, xfalib);(function(_, $, xfalib){
    var btwn = xfalib.ut.XfaUtil.prototype.btwn;

    xfalib.view.FieldView =  xfalib.view.BaseView.extend({
        //list of RTL languages
        _rtlLang:{he : "he", ar : "ar", fa: "fa"},

        _addOns:{
            "x-scribble-add-on" : xfalib.template.Constants.ScribbleImageField
        },
        initialize : function() {
            xfalib.view.BaseView.prototype.initialize.apply(this, arguments);
            this.captionLayoutModel = null;
            this.widgetLayoutModel = null;
            this.jqWidget = null;
            this.commitEvent = this.options.commitEvent;
            this.commitProperty = this.options.commitProperty;
            this.commitTarget = this.options.commitTarget;
            this.isError = false;

            this.caption = this._findCaption();
            this.widget = this._findWidget();
            if (this.widget) {
                this.createBorderForWidget();
                if(this.commitEvent != null) {
                    $(this.widget).on(this.commitEvent,
                        this._bind(this, this.handleCommit));
                }
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT,
                    this._bind(this, this.handleClickEvent));
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    this._bind(this, this.handleFocusOut));
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    this._bind(this, this.handleChangeEvent));
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
                    this._bind(this, this.handleFocusEvent));
                $(this.widget).on("keypress",
                    this._bind(this, this.handleKeyPressEvent));
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_PREOPEN_EVENT,
                    $.proxy(this.handlePreOpenEvent, this));
            }
            var that = this;
            if(this.caption) {
                this.$css(this.caption,{"cursor":"default"});
                //add presentation role to caption
                $(this.caption).attr("role", "presentation")
            }
            $(this.$el).on("mousedown", $.proxy(this._handleMouseDown,this))
                       .on("click", function(event) {
                            if(that.model.mEffectiveAccess != "open") {
                               return;
                            }
                            //label is clicked click the widget
                            if(!$(event.target).closest(".widget").length) {
                                that.jqWidget.click();
                            }
                        });
            this._initLayout();
        },

        createBorderForWidget : function(){
            if(this.model){
                var ui = this.model.getElement("ui", 0,true);
                var fill,color ;
                if(ui) {
                    var border = ui.oneOfChild.getElement("border", 0,true);
                    if(border && border.presence == "visible") {
                        if(this.caption  && parseInt(this.model.caption.getAttribute("reserve"))!=0  && this.model.parent.className !="exclGroup"){
                            var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(border);
                            if(cssStyleObj)
                                this.$css(this.widget, cssStyleObj);
                        } else if(!this.edgePresence  && this.model.parent.className !="exclGroup") {
                            var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(border);
                            if(cssStyleObj)
                                this.$css(this.widget, cssStyleObj);
                        }
                    }
                    if(border && (fill = border.getElement("fill",0,true)) && (color = fill.getElement("color",0,true))
                        && fill.presence!="hidden"
                        && fill.presence !="invisible"
                       ) {
                        var color = color.value;
                        if(color == "")
                            color="255,255,255";  // if no color value is specified then fill default color
                        color = "rgb(" + color + ")";
                        $(this.widget).css("background-color", color);
                    }
                }
            }
        },


        _handleMouseDown: function(event) {
            if( !$(event.target).closest(".widget").length && xfalib.view.FieldView.prototype.currentFocus == this ) {
                this.clickedOnCaption = true;
            }
        },

        _markAccess : function(access) {
            switch(access) {
                case "open" :
                    $(this.widget).removeClass("widgetreadonly");
                    break;
                case "nonInteractive" :
                case "protected" :
                    $(this.widget).addClass("widgetreadonly");
                    break;
                case "readOnly" :
                    $(this.widget).addClass("widgetreadonly");
                    break;
            }
        },

        _initLayout : function(){
            xfalib.view.BaseView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                this._initializeFieldChildLayoutAndExtent();
                this._syncFormNodeToHtml(true);
                this.markMandatory();
                this.$css(this.el, {"z-index": 2});
                if(this.caption){
                    //This is to avoid truncation of svg text when SVG is larger than containing div.
                    //In that case we allow SVG to be large upto extent of 120% of the assigned draw extents
                    // Each browser handles svg differently. Below fix works for all supported browser and avoid 20% truncation which would handle most common cases.
                    // Actual fix would require exact combined svg height/width calculation probably in XTG side.
                    var captionSVG = $(this.caption).children("svg").get(0);

                    // Due to extra 20%, Button-1 and Button-2 placed next to each other overlaps.
                    // So when clicking on Button-2, click on Button-1 gets triggered because of Button-1 overlapping area
                    // Removing extra 20% and hiding overflown SVG text for button field.

                    // Checking for submit and radio button
                    var hasParentButtonField = $(this.caption).parent().length && $(this.caption).parent().hasClass('buttonfield');
                    var hasSiblingButtonField = $(this.caption).siblings().length && $(this.caption).siblings().hasClass('buttonfieldwidget');
                    var hasParentRadioButtonField = $(this.caption).parent().length && $(this.caption).parent().hasClass('radiofield');
                    var hasSiblingRadioButtonField = $(this.caption).siblings().length && $(this.caption).siblings().hasClass('radiofieldwidget');
                    if(captionSVG){
                        $(captionSVG).attr('focusable', 'false'); //LC-7105 LC-5444 svg tabIndex doesn't work so adding focusable as false
                        //CQ-4274732 : To prevent svg being read out. Caption(svg) and input both are being read by screen reader, only focussable should be read.
                        $(captionSVG).attr('aria-hidden', 'true');
                        var captionChildExtent = {};
                        if((hasParentButtonField && hasSiblingButtonField) || (hasParentRadioButtonField && hasSiblingRadioButtonField)){
                            captionChildExtent["width"] = "100%";
                            captionChildExtent["height"]= "100%";
                            $(this.caption).css("overflow", "hidden");
                        }else{
                            captionChildExtent["width"] = "120%";
                            captionChildExtent["height"]= "120%";
                        }
                        this.$css(captionSVG, captionChildExtent);
                        if($.browser.webkit || $.browser.chrome || xfalib.ut.Utilities.checkMinMozillaVersion(28)){
                            //chrome handles the rtl text element in a different way.
                            //there is a similar function in XfaDrawView
                            $(captionSVG).children('text[direction="rtl"]').attr('x', this._adjustTextCoordinate);

                        }
                    }
                }
                //Invalidate the tab indexes for the page containing this field when this field is initialized.
                //This would just queue the tabbing computation for this particular page.
                this._xfaViewRegistry().invalidateTabIndex(this._pageNumber());
            }
        },

        handlePreOpenEvent: function(event) {
                this.model.execEvent("preOpen");
        },

        handleFocusEvent: function(event) {
            if(!this.clickedOnCaption) {
                this.model._xfa().setSubformFocus(this.model.parentSubform);
                this.model.execEvent("enter");
            }
            this.clickedOnCaption = false; // reset the state
            xfalib.view.FieldView.prototype._setFocusParam(this);
            if(formBridge) {
                if(formBridge.isAnalyticsEnabled) {   //Only computing when analytics enabled
                    var prevFocus=xfalib.view.FieldView.prototype.prevFocus,
                        currFocus=xfalib.view.FieldView.prototype.currentFocus;
                    if(prevFocus){  //if prevFocus is already null then no need to pass SOM Expression
                        prevFocus=prevFocus.model.somExpression;
                    }
                    if(currFocus){ //if currFocus is already null then no need to pass SOM Expression
                        currFocus=currFocus.model.somExpression;
                    }
                    xfalib.ut.XfaUtil.prototype._triggerOnBridge("elementFocusChanged", this.model, "focus", prevFocus, currFocus);
                }
                formBridge.clickedOnWindow = false;
            }
        },

        handleFocusOut : function(event) {
            if(!this.clickedOnCaption) {
                this.model.execEvent("exit");
            }
            if(formBridge && formBridge.clickedOnWindow === true) {
                xfalib.view.FieldView.prototype._setFocusParam(null);
                formBridge.clickedOnWindow = false;
            }
        },

        _setFocusParam : function(currFocus) {
            xfalib.view.FieldView.prototype.prevFocus = xfalib.ut.Class.prototype.getOrElse(xfalib.view.FieldView.prototype.currentFocus, null);
            //To minimize regression impact as "xfalib.view.FieldView.prototype.currentFocus" is used at all the places in the code
            xfalib.view.FieldView.prototype.currentFocus=currFocus;
        },

        _clearFocusInfo : function() {
            xfalib.view.FieldView.prototype.prevFocus = null;
            xfalib.view.FieldView.prototype.currentFocus=null;
        },

        handleKeyPressEvent: function(event) {
            var code = event.charCode || event.which || event.keyCode || 0;
            var character = String.fromCharCode(code);

            if(xfalib.ut.XfaUtil.prototype.isNonPrintableKey(event.key)) { // mozilla also generates a keypress, along with keydown
                return true;                                               // for all keys, so only handling printable keys in keypress
            }

            if(this.character != undefined) { // takes care of cases when xfa.event.change is set by user script
                if(this.character == null) {
                    this.jqWidget.option("value",this.jqWidget.option("curValue"));
                    this.jqWidget.option("displayValue",this.jqWidget.option("curValue"));
                }
                else if(this.character != character &&
                    !(event.key === "Enter" && this.character === "\n")) {
                    //String.fromCharCode returns \r for Enter key, but character is \n - ignore this mismatch
                    this.jqWidget.option("value",this.current);
                    this.jqWidget.option("displayValue",this.current);
                    event.preventDefault();
                }
                this.character = undefined;
            }
        },

        _syncFormNodeToHtml : function(deepSync) {
            var pluginOptions = this._createPluginOptions();
            if(!this.jqWidget)
                this.createWidgetPlugin(pluginOptions);
            else {
                _.each(pluginOptions, function(value, key){
                    this.jqWidget.option(key, value);
                }, this);
            }
            this._markAccess(this.model.mEffectiveAccess)
            if(this.model.__errorText)
                this._deferredMarkError();
            xfalib.view.BaseView.prototype._syncFormNodeToHtml.apply(this, arguments);
        },

        handleModelChanged : function(event) {
            if (event._property == this.commitTarget) {
                this._handleValueChange(event);
            }
            else{
                switch(event._property) {
                    case "focus":
                        this._focusWidget(this);
                        break;
                    case "ValidationState" :
                        this._markError(event);
                        break;
                    case "change":
                        this._handleEventChangeProperty(event);
                        break;
                    case "ClearError":
                        this._clearError(event);
                        break;
                    case "fillColor":
                        this._fillColor(event.newText);
                        break;
                    default:
                        xfalib.view.BaseView.prototype.handleModelChanged.apply(this,
                            arguments);
                }

            }
        },

        handleDomChanged :function(event){
            switch(event._property) {
                case "font.fill.color.value":
                    this._handleFontFillColorValue(event.prevText);
                    break;
                case "font.posture":
                    this._handleFontPosture(event.prevText);
                    break;
                case "value.maxChars":
                    this._handleMaxChars(event);
                    break;
                case "caption.font.fill.color.value":
                    this._handleCaptionFontFillColorValue(event);
                    break;
                case "nullTest":
                    this._handleNullTest(event, $(this.widget));
                    break;
                default:
                    xfalib.view.BaseView.prototype.handleDomChanged.apply(this, arguments);
            }
        },

        _handleNullTest: function (event, $target) {
            this._handleMandatory(event.newText, $target);
            this._handleDisabled(event);
        },

        _handleMandatory: function (change, $target) {
            if (_.contains(['disabled', 'warning'], change)) {
                $target.attr('data-mandatory', 'false')
                       .removeClass('widgetMandatoryBorder');
            } else if (change === 'error') {
                $target.attr('data-mandatory', 'true')
                       .toggleClass("widgetMandatoryBorder", xfalib.globals.highlight);
            }
        },

        _handleDisabled: function(event){
           var change = event.newText;
           if (change === 'disabled') {
              this._clearError(event);
           }
        },


        _handleCaptionFontFillColorValue :function(event) {
            var childSvg = this.caption.children[0];
            var fill = "rgb(" + event.prevText + ")" ;

            if(childSvg.tagName == "svg" && childSvg.childNodes) {
              _.each(childSvg.childNodes,function(node,index){
                if(node.tagName == 'text') {
                    this.$css(node,{'fill' : fill});
                }
              },this);
            }
        },

        _handleFontFillColorValue : function (value) {
            this.jqWidget.option("color", value);
        },

        _handleFontPosture : function (value) {
            this.jqWidget.option("font-style", value);
        },

        _handleMaxChars : function(event) {
            var maxchars = event.prevText;
            if(maxchars)
                this.jqWidget.option("maxChars",event.prevText);
        },

        handleCommit : function(event) {
            var resizeRqd = false;
            if(this.resizable && this.jqWidget.option("value") != this.model[this.commitTarget])
                resizeRqd = true;
            this.model[this.commitTarget] = this.jqWidget.option("value");
            if(resizeRqd)
                this.invalidateSize();
        },

        handleChangeEvent : function(changeEvent) {
            var current,
                event = changeEvent.originalEvent,
                maxChars = parseInt(this.jqWidget.option("maxChars") || this.jqWidget.option("combCells")) || 0, // to take care for both text & numeric fields
                val = this.jqWidget.option("curValue") || this.jqWidget.option("displayValue") || '',
                selectionStart = event.selectionStart,
                selectionEnd = event.selectionEnd,
                code = event.charCode || event.keyCode || event.which,
                character = event.character || '',
                change,
                fullText;

            if(event.originalType == "cut") {
                change = "";
                if(val) {
                    current = val.substr(0, selectionStart) + val.substr(selectionEnd);
                    fullText = current;
                }
            } else if(event.originalType == "keydown") {
                change = "";

                if(val) {
                    if (code == 8 || code == 46) {  // backSpace or Del
                        if (selectionStart !== selectionEnd) {
                            current = val.substr(0, selectionStart) + val.substr(selectionEnd);
                        } else {
                            if (code == 8) {  // backspace
                                current = val.substr(0, selectionStart - 1) + val.substr(selectionStart);
                            }
                            if (code == 46) {  // del
                                current = val.substr(0, selectionStart) + val.substr(selectionStart + 1);
                            }
                        }
                    }
                } else {
                    current = val;
                }
                fullText = current;
            }
            else { // keypress or paste
                change = character;
                if (maxChars > 0 ) {
                    if (val.length - (selectionEnd - selectionStart) >= maxChars) {
                        change = "";
                    } else {
                        change = character.substr(0, maxChars - val.length + selectionEnd - selectionStart);
                    }
                }

                if (val) {
                    current = val.substr(0, selectionStart) + change + val.substr(selectionEnd);
                    fullText = val.substr(0, selectionStart) + character + val.substr(selectionEnd);

                } else {
                    current = change;
                    fullText = character;
                }

                if( (maxChars !=0 && current.length  > maxChars) || !this.jqWidget.option("lengthLimitVisible") ) {
                    change = "";
                    current = val;
                }

                // LC-6290 : prevent paste from truncating any of the previous text
                if (event.originalType == "paste" &&
                    ((maxChars != 0 && fullText.length > maxChars) || !this.jqWidget.option("lengthLimitVisible"))) { // TODO : take care of multiline selection later
                    var self = this;
                    self.jqWidget.$userControl.one("input", function () {  // wait till the paste action occurs and then replace with correct value
                        self.jqWidget.$userControl.val(current)
                                                  .prop("selectionStart", selectionEnd) // LC-6290 : reset the cursor pos afterwards
                                                  .prop("selectionEnd", selectionEnd);
                    });
                }
            }

            var detail = {
                prevText:val,
                keycode:code,
                modifier:event.ctrlKey,
                keyDown: event.keyDown,
                shift:event.shiftKey,
                change:change,
                newText:current,
                fullText: fullText
            };
            if(!!change || current != val)
                this.model.execEvent("change", detail);
        },

        handleClickEvent : function(event) {
            var prevValue= this.jqWidget.option("value");
            var detail = {
                keycode:event.which,
                modifier:event.ctrlKey,
                shift:event.shiftKey
            };
            this.model.execEvent("click", detail);
        },

        _handleEventChangeProperty : function(event) {
            this.character = event.prevText;
            var prevValue= this.jqWidget.option("curValue") || this.jqWidget.option("displayValue") || "";
            var pos = this.jqWidget.options.pos ;
            this.current = prevValue.substr(0, pos) + this.character + prevValue.substr(pos);
            //var value = this.jqWidget.option("value") || "" ;
            //var displayValue = this.jqWidget.option("displayValue") || ""   ;

        },

        _handleValueChange : function(event) {
            //xfa.Logger.debug("[FieldView._handleValueChange]value:som"
            //        + event.newText + ":" + this.$el.data("som"));
            var resizeRequired =  (this.jqWidget.option("displayValue") != event.newText) && this.resizable ;
            this.jqWidget.option("value",event.prevText);
            this.jqWidget.option("displayValue",event.newText);
            if(resizeRequired){
                this.invalidateSize();
            }
        },

        _markError : function(evnt) {
            //this.$css(this.widget, "background-color","#D3D3D3");
            $(this.widget).addClass("widgetError");
            this.jqWidget.markError(evnt.newText, evnt.prevText);
            this._updateWidgetOption("isValid",false);
        },

        _deferredMarkError : function() {
            //this.$css(this.widget, "background-color","#D3D3D3");
            if(this.model.mandatory == "error")
                $(this.widget).addClass("widgetError");
            this.jqWidget.markError(this.model.__errorText, this.model.mandatory);
            this._updateWidgetOption("isValid",false);
        },

        _clearError : function(evnt) {
            //this.$css(this.widget, "background-color", "white");
            $(this.widget).removeClass("widgetError");
            this.jqWidget.clearError();
            this._updateWidgetOption("isValid",true);
        },

        // for all fields
        _updateWidgetOption: function(optionName, optionValue){
            this.jqWidget.option(optionName, optionValue);
        },

        _handleAccessChange : function(event) {
            //xfa.Logger.debug("[_handleAccessChange]access:som"
            //        + event.newText + ":" + this.$el.data("som"));
            this.jqWidget.option("access",event.newText);
            if(event.newText != event.prevText)
                this._markAccess(event.newText)
        },

        _findWidget : function() {
            if (this.$el.hasClass("widget"))
                return this.$el.get(0);
            else {
                var widgetList = this.$el.find(".widget");
                if (widgetList.length > 0){
                    return widgetList.get(0);
                }
            }
        },
        _findCaption : function() {
            var captionList = $(".caption", this.$el);
            if (captionList.length > 0){
                return captionList.get(0);
            }
        },

        _getParaStyles : function(){
            var paraStyles = {},para;
            para = this.model.getElement("para", 0, true);
            if(para){
                paraStyles = {
                    "text-align" : para.hAlign,
                    "vertical-align" : para.vAlign,
                    "text-indent" : this._convertToPx(para.textIndent),
                    "padding-left" : this._convertToPx(para.marginLeft),
                    "padding-right" : this._convertToPx(para.marginRight),
                    "padding-top" : this._convertToPx(para.spaceAbove),
                    "padding-bottom" : this._convertToPx(para.spaceBelow)
                };
            }
            return paraStyles;
        },

        _createPluginOptions : function() {
            if(this.model){
                var value = this.model[this.commitTarget] || null;
                var screenReaderText;
                screenReaderText = this._getScreenReaderText();
                var tabIndex = 0;
                if(this.model.jsonModel.extras && this.model.jsonModel.extras.tabIndex) {
                    tabIndex = this.model.jsonModel.extras.tabIndex;
                }

                var lang = this._langFromLocale(this.model._getLocale());
                var direction;

                if(lang && this._rtlLang[lang]){
                    direction = "rtl";
                }

                var paraStyles = this._getParaStyles();
                var widgetModel = this.widgetLayoutModel || this.layoutModel;
                return {
                    "name" : this.model.jsonModel.name+""+this._id,
                    "value" : value,
                    "displayValue": this.model.formattedValue,
                    "commitProperty" : this.commitProperty,
                    "access": this.model.mEffectiveAccess,
                    "platform": this.model._xfa().host.platform,
                    "screenReaderText": screenReaderText,
                    /*"tabIndex": tabIndex,*/
                    "paraStyles" : paraStyles,
                    "dir" : direction,
                    "hScrollDisabled" : !this.resizable && this.model.ui.oneOfChild.hScrollPolicy === "off",
                    "height" : widgetModel.extenth + widgetModel.bordertop/2 + widgetModel.borderbottom/2,
                    "commitEvent" : this.commitEvent
                };
            }

        },

        _getScreenReaderText: function () {
            var screenReaderText = "";
            if (this.model) {
                var assist = this.model.getElement("assist", 0, true);
                if (this.getOrElse(assist, "speak.disable", 0) != 1) { // loose compare string value

                    var priority = this.getOrElse(assist, "speak.priority", "speak"),
                        candidates = {
                            "speak": this.getOrElse(assist, "speak.value", ""),
                            "caption": this.getOrElse(this.model, "jsonModel.extras.caption", ""),
                            "toolTip": this.getOrElse(assist, "toolTip.value", ""),
                            "name": this.getOrElse(this.model, "jsonModel.name", "")
                        };

                    screenReaderText = candidates[priority] ||
                                       candidates["speak"] ||
                                       candidates["caption"] ||
                                       candidates["toolTip"] ||
                                       candidates["name"];
                    // CQ-85183 : going against xfa spec (pg 505) prioritise caption over tooltip
                }
            }
            return screenReaderText;
        },

        _assignToolTip: xfalib.view.XfaDrawView.prototype._assignToolTip,

		_instantiateWidget:function(widgetName,options){
		    if (widgetName && widgetName.length > 0) {
                    try{
                        $(this.widget)[widgetName](options);
                        return this.$data(this.widget, widgetName) ||
                               this.$data(this.widget, "xfaWidget-"+widgetName);
                    } catch(exception) {
                        xfalib.runtime.xfa.Logger.error("xfaView", "exception "+exception.message+" in creating user widget. widget:"+widgetName);
                    }
            }
		},
        _createScribbleWidgetOptions:function(options){
            var initParams = this.getOrElse(this.model.ui,"extras.children",null);
            var geoLocParam = _.find(initParams,function(obj){
	            return obj&&obj.name=="geoLocMandatoryOnIpad";    
            });

            var geoLocMandatoryOnIpad = (geoLocParam&&geoLocParam.value) || ( window.formBridge.userConfig
                                         && window.formBridge.userConfig['scribbleImageFieldConfig']
                                         && window.formBridge.userConfig['scribbleImageFieldConfig'].geoLocMandatoryOnIpad );
            return _.extend({
                              geoLocMandatoryOnIpad:geoLocMandatoryOnIpad
                            },options);
        },
        createWidgetPlugin : function(options) {
            var widgetConfig = this._xfaViewRegistry().widgetConfig();
            var widgetName;
			
            if(widgetConfig){
                    widgetName = _.filter(widgetConfig,
                    function(widgetName, selector){
                        if(this.$el.filter(selector).length >0)
                            return true;
                        else
                            return false;
                    },
                    this)[0];
            } 

            this.jqWidget = this._instantiateWidget(widgetName,options);
			
            if(!this.jqWidget){
                widgetName = this._getWidgetNameFromUiExtra();
                if (widgetName) {
                    this.jqWidget = this._instantiateWidget(widgetName, this._createScribbleWidgetOptions(options));
                }
            }
			
            if(!this.jqWidget){
					this._createDefaultWidgetPlugin(options);
			}
            xfalib.runtime.xfa.Logger.debug("xfaView", "creating user widget. widget:" + this.jqWidget._widgetName
            + " for " + this.model.somExpression);
        },

        /**
        * returns the name of the widget present in ui extras
        * @returns {string} widgetName
        */
        _getWidgetNameFromUiExtra : function () {
            var widgetName = null,
                uiExtrasName = this.getOrElse(this,"model.ui.extras.name",null);
            if(uiExtrasName && uiExtrasName.length >= 2 && this._addOns.hasOwnProperty(uiExtrasName)){
                widgetName = this._addOns[uiExtrasName];
            }
            return widgetName;
        },

        _createDefaultWidgetPlugin : function(options) {
            $(this.widget).defaultWidget(options);
            this.jqWidget = this.$data(this.widget, "xfaWidget-defaultWidget");
        },

        markMandatory : function(){
            if(this.model.mandatory== "error")
                if(this.widget)
                    $(this.widget).attr("data-mandatory", "true") ;

        },

        _initializeFieldChildLayoutAndExtent : function() {
            if (this.caption) {
                var cView = _.extend({}, xfalib.view.BaseView.prototype, {
                    el : this.caption,
                    $el : $(this.caption)
                });
                xfalib.view.BaseView.prototype._initializeLayoutModel.apply(cView);  //TODO: handle things when moving layout to formDom
                this.captionLayoutModel = cView.layoutModel;
            }
            if (this.widget && this.caption) {
                var wView = _.extend({}, xfalib.view.BaseView.prototype, {
                    el : this.widget,
                    $el : $(this.widget)
                });
                xfalib.view.BaseView.prototype._initializeLayoutModel.apply(wView);
                this.widgetLayoutModel = wView.layoutModel;
            }
        },

        _getMeasurementOptions : function(){
            var widgetModel = this.widgetLayoutModel || this.layoutModel;
            return ({
               refEl : this.jqWidget && this.jqWidget.$userControl ? this.jqWidget.$userControl[0] : null,
               width : (widgetModel.extentw - widgetModel.marginleft - widgetModel.marginright),
               height : (widgetModel.extenth - widgetModel.margintop - widgetModel.marginbottom),
               minWidth : (widgetModel.extentminw>-1)?(widgetModel.extentminw - widgetModel.marginleft - widgetModel.marginright):widgetModel.extentminw,
               minHeight :(widgetModel.extentminh>-1)?(widgetModel.extentminh - widgetModel.margintop - widgetModel.marginbottom):widgetModel.extentminh,
               maxWidth : (widgetModel.extentmaxw > -1)?(widgetModel.extentmaxw - widgetModel.marginleft - widgetModel.marginright):widgetModel.extentmaxw,
               maxHeight :(widgetModel.extentmaxh > -1)?(widgetModel.extentmaxh - widgetModel.margintop - widgetModel.marginbottom):widgetModel.extentmaxh
            });
        },

        measureSize : function(){
            var resized = false;
            if(this.resizable){
                var text = (this.model && this.model[this.commitTarget]!= null)? this.model[this.commitTarget] : "";
                resized = this._updateWidgetModel(text);
                if(resized && this.caption && this.widget && this.model.caption) {
                    switch(this.model.caption.getAttribute("placement")){
                        case "left":
                        case "right":
                            this.layoutModel.extentw  = this.layoutModel.marginleft + this._getCaptionReservedW() + this.widgetLayoutModel.extentw + this.layoutModel.marginright;
                            this.layoutModel.extenth = this.layoutModel.margintop + Math.max(this._getCaptionReservedH(), this.widgetLayoutModel.extenth) + this.layoutModel.marginbottom;
                            break;
                        case "top":
                        case "bottom":
                            this.layoutModel.extentw = this.layoutModel.marginleft + Math.max(this._getCaptionReservedW(), this.widgetLayoutModel.extentw) + this.layoutModel.marginright     ;
                            this.layoutModel.extenth  = this.layoutModel.margintop + this._getCaptionReservedH() + this.widgetLayoutModel.extenth + this.layoutModel.marginbottom;
                            break;
                    }
                }
            }
            return resized;
        },

        /**
         * @function
         * To update height and width of widget model
         * @param {String} text : text to be used to compute new height and width
         * return true if height or width updated else false
         */
        _updateWidgetModel : function (text) {
            var spaceAbove = 0,
                spaceBelow = 0,
                para = this.getOrElse(this, "model.para", null),
                resized = false,
                measureOptions = this._getMeasurementOptions(),
                measuredExtent = xfalib.view.util.TextMetrics.measureExtent(text, _.clone(measureOptions)),
                widgetModel = this.widgetLayoutModel || this.layoutModel;

            if(para) {
                spaceAbove = para.spaceAbove;
                spaceBelow = para.spaceBelow;
            }

            if(measureOptions.width != measuredExtent.width || measureOptions.height != measuredExtent.height) {
                resized = true;
                if(measureOptions.width != measuredExtent.width) {
                    widgetModel.extentw = widgetModel.marginleft + measuredExtent.width + widgetModel.marginright;
                }
                if(measureOptions.height != measuredExtent.height) {
                    widgetModel.extenth = widgetModel.margintop + measuredExtent.height + widgetModel.marginbottom + this._convertToPx(spaceAbove)
                        + this._convertToPx(spaceBelow);
                }
            }
            return resized
        },

        _getCaptionReservedW: function() {
            if(this.caption && this.model.caption){
                switch(this.model.caption.getAttribute("placement")) {
                    case "left" :
                    case "right" :
                        //in case left and right, "reserve" dictates the width of the caption
                        var reserve = this.model.caption.getAttribute("reserve");
                        return (reserve != "-1" ? this._convertToPx(reserve) : 0);
                        break;
                    case "top" :
                    case "bottom" :
                        return this.captionLayoutModel.extentw;
                        break;
                }
            }
            return 0;
        },

        _getCaptionReservedH: function() {
            if(this.caption && this.model.caption){
                switch(this.model.caption.getAttribute("placement")) {
                    case "left" :
                    case "right" :
                        return this.captionLayoutModel.extenth;
                        break;
                    case "top" :
                    case "bottom" :
                        //in case top and bottom, "reserve" dictates the height of the caption
                        var reserve = this.model.caption.getAttribute("reserve");
                        //CQ-102341 : Layout of older forms got disturbes which had no reserve value. So if no reserve is found the older value i.e this.captionLayoutModel.extenth is returned
                        return (this._isReservePresent(reserve) ? this._convertToPx(reserve) : this.captionLayoutModel.extenth);
                        break;
                }
            }
            return 0;
        },

        _isReservePresent: function(reserve) {
            try {
                return !(reserve == "-1" || parseFloat(reserve.replace(/[^-\d\.]/g, '')) == 0);
            } catch(exception) {
                xfalib.runtime.xfa.Logger.warn("xfa","issue with parseFloat of reserve , reserve value :" + reserve);
                return false;
            }
        },

        _calculateDisplay : function(capExtent,wExtent) {
             wExtent["width"] = this.widgetLayoutModel.extentw + this.widgetLayoutModel.borderleft/2 + this.widgetLayoutModel.borderright/2 ;
             wExtent["height"] = this.widgetLayoutModel.extenth + this.widgetLayoutModel.bordertop/2 + this.widgetLayoutModel.borderbottom/2 ;
             switch(this.model.caption.placement) {
               case "left" :
                  capExtent["left"] = this._padLeft();
                  capExtent["top"] = this._padTop();
                  wExtent["left"] = this._padLeft() + this._getCaptionReservedW();
                  wExtent["top"] = this._padTop();
                  break;
               case "right" :
                  capExtent["right"] = this._padRight();
                  capExtent["top"] = this._padTop();
                  wExtent["right"] = this._padRight() + Math.max(this._getCaptionReservedW(), capExtent["width"]);
                  wExtent["top"] = this._padTop();
                  break;
               case "top" :
                  capExtent["left"] = this._padLeft();
                  capExtent["top"] = this._padTop();
                  wExtent["left"] = this._padLeft();
                  wExtent["top"] = this._padTop() + this._getCaptionReservedH();
                  break;
               case "bottom" :
                  capExtent["left"] = this._padLeft();
                  capExtent["bottom"] = this._padBottom();
                  wExtent["left"] = this._padLeft();
                  wExtent["bottom"] = this._padBottom()  + this._getCaptionReservedH();
                  break;
           }
       },

        updateDisplay : function(){
            xfalib.view.BaseView.prototype.updateDisplay.apply(this, arguments);
            if(this.caption && this.widget){
                var parentPadLeft = this._padLeft();
                var parentPadTop = this._padTop();
                var capExtent = {};
                var wExtent = {};
                capExtent["width"] = this.captionLayoutModel.extentw + this.captionLayoutModel.borderleft/2 + this.captionLayoutModel.borderright/2 ;
                capExtent["height"] = this.captionLayoutModel.extenth + this.captionLayoutModel.bordertop/2 + this.captionLayoutModel.borderbottom/2 ;
                this._calculateDisplay(capExtent,wExtent);
                this.jqWidget.option("width",this.widgetLayoutModel.extentw - this.widgetLayoutModel.marginleft - this.widgetLayoutModel.marginright)
                             .option("height",this.widgetLayoutModel.extenth - this.widgetLayoutModel.marginbottom - this.widgetLayoutModel.margintop)
                this.$css(this.caption, capExtent);
                this.$css(this.widget, wExtent);
            }
            else {
                this.jqWidget.option("width",this.layoutModel.extentw - this.layoutModel.marginleft - this.layoutModel.marginright)
                             .option("height",this.layoutModel.extenth - this.layoutModel.marginbottom - this.layoutModel.margintop)
            }
        },

        updateTabIndex : function(newTabIndex){
            this.jqWidget.option("tabIndex", newTabIndex);
        },

        // CQ-102472 : Overriding BaseView _handleBorderChange, as in case of field with no caption, field border color gets assigned to widget border as no caption and field divs are present
        _handleBorderChange : function(event) {
            if (this.caption || this.model.border.edge.getAttribute("thickness", false)) {
                var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(this.model.border);
                if(cssStyleObj) {
                    this.$css(this.el, cssStyleObj);
                }
            }
        }

    });
})(_, $, xfalib);

(function(_, $, xfalib){
    xfalib.view.CheckButtonFieldView = xfalib.view.FieldView.extend({

        initialize : function(){
            xfalib.view.FieldView.prototype.initialize.apply(this, arguments);
        },

        _createDefaultWidgetPlugin :  function(options){
            if(this.model){
                options.size =  this.model.ui.oneOfChild.size;
                options.state = this.model.selectedIndex;
                options.states = this.model.ui.oneOfChild.allowNeutral == "1" ? 3:2;  // #bug=3650920, typeof allowNeutral is string
                $(this.widget).XfaCheckBox(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-XfaCheckBox");
            }
            else{
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this, [options]);
            }
        },

        /*
        //Note: The screenreader text for exclusion group should not behave differently, and should be aligned to PDF.
        //Reference: CQ-81875 (AEM Forms show radio button name included with tooltip)
        _getScreenReaderText: function() {
            var screenReaderText =  xfalib.view.FieldView.prototype._getScreenReaderText.apply(this),
                screenReaderTextParent;
            if(this.model.parent && this.model.parent._isExclusionGroup()) {
                screenReaderTextParent = this.parentView._getScreenReaderText();
                if(screenReaderTextParent) {
                    screenReaderTextParent = screenReaderTextParent + " " ;
                    if(screenReaderText) {
                        screenReaderText= screenReaderTextParent  +   screenReaderText;
                    } else {
                        screenReaderText = screenReaderTextParent;
                    }
                }
            }
                return  screenReaderText ;

        },
        */
        _handleMouseDown: function(event) {
            if(xfalib.view.FieldView.prototype.currentFocus == this) {
                this.clickedOnCaption = true;
            }
        },

        createBorderForWidget : function(){
        },

        handleChangeEvent : function(event) {
            if(this.model.parent.className == "exclGroup") {
                this.model.parent.execEvent("change");
            }
            this.model.execEvent("change");
        },

        handleClickEvent : function() {
            if(this.model.parent.className == "exclGroup") {
                this.model.parent.execEvent("click");
            }
            this.model.execEvent("click");
        },

        handleDomChanged :function(event){
            switch(event._property) {
                case "allowNeutral":
                    this._handleAllowNeutral(event);
                    break;
                default:
                    xfalib.view.FieldView.prototype.handleDomChanged.apply(this, arguments);
            }
        },

         _calculateDisplay : function(capExtent,wExtent) {
               var size = this._getWidgetReserved();  //-- we are changing the calculations from caption-centric to a widget centric
               this.widgetLayoutModel.extentw = this.widgetLayoutModel.extenth = size;
               var parentExtent = {};
               var paraField = this.model.getElement("para")
               if(paraField)
                 var vAlignWidget = paraField.getAttribute("vAlign");
               parentExtent["width"] = this.layoutModel.extentw + this.layoutModel.borderleft/2 + this.layoutModel.borderright/2 ;
               parentExtent["height"] = this.layoutModel.extenth + this.layoutModel.bordertop/2 + this.layoutModel.borderbottom/2 ;
               wExtent["width"] = this.widgetLayoutModel.extentw + this.widgetLayoutModel.borderleft/2 + this.widgetLayoutModel.borderright/2 ;
               wExtent["height"] = this.widgetLayoutModel.extenth + this.widgetLayoutModel.bordertop/2 + this.widgetLayoutModel.borderbottom/2 ;
               var topBottomPadding = (this.layoutModel.extenth-(this.widgetLayoutModel.extenth + this.captionLayoutModel.extenth))/2;

               switch(vAlignWidget) { // setting the vAlign of the widget equal to its parent. (i.e field)
                 case "bottom":
                        wExtent["bottom"]= this._padBottom();
                        break;
                  case "middle":
                        wExtent["top"] = (this.layoutModel.extenth-size)/2;
                        break;
                  case "top":
                  default:
                        wExtent["top"]= this._padTop();
               }

               switch(this.model.caption.placement) {
                    case "right" :
                        capExtent["left"] = this._padLeft() + size;
                        capExtent["top"] = this._padTop();
                        wExtent["left"] = this._padLeft()
                        break;
                    case "left" :
                        capExtent["right"] = this._padRight() + size;
                        capExtent["top"] = this._padTop();
                        wExtent["right"] = this._padRight();
                        break;
                    case "bottom" :
                        capExtent["left"] = this._padLeft();
                        capExtent["top"] = this._padTop()+ size + topBottomPadding;
                        wExtent["left"] = this._padLeft();
                        wExtent["bottom"]= undefined;
                        wExtent["top"] = this._padTop() + topBottomPadding ;
                        break;
                    case "top" :
                        capExtent["left"] = this._padLeft();
                        capExtent["bottom"] =this._padBottom()+ size + topBottomPadding;
                        wExtent["top"]= undefined;
                        wExtent["left"] = this._padLeft();
                        wExtent["bottom"] = this._padBottom()+ topBottomPadding;
                        break;
               }
               var lang = this._langFromLocale(this.model._getLocale());
               var direction = "ltr"
               if(lang && this._rtlLang[lang]){
                 direction = "rtl";
               }
               if(capExtent["width"]<(parentExtent["width"] - wExtent["width"])) {
                   switch(this.model.caption.placement) {
                       case "right" :
                           capExtent["left"] =  parentExtent["width"]-capExtent["width"] ;
                           break;
                       case "left" :
                           capExtent["right"] = undefined;
                           capExtent["left"] = this._padLeft();
                           wExtent["right"] = direction === "rtl" ? 0 : undefined
                           wExtent["left"] = direction === "rtl" ? undefined : this._padLeft()+capExtent["width"];
                           break;
                   }
               }
               if(capExtent["height"]<(parentExtent["height"] - wExtent["height"])) {
                   switch(this.model.caption.placement) {
                       case "bottom" :
                           capExtent["top"] = parentExtent["height"]-capExtent["height"];
                           break;
                       case "top" :
                           capExtent["bottom"] = parentExtent["height"]-capExtent["height"];
                           break;
                   }
               }

         },


        _getWidgetReserved: function() {
            if(this.widget ){
                 var size = this.model.ui.oneOfChild.getAttribute("size");
                 return (size != "-1" ? this._convertToPx(size) : 0);
            }
        },

        _handleAllowNeutral : function(event) {
            if(event.prevText) {
                if(event.prevText == "0" && this.model.getItemState(2)) {  // if button was in neutral,
                    this.model.setItemState(1, true);   // set it to off, while disabling allowNeutral
                }
                this.jqWidget.option("allowNeutral", event.prevText);
            }
        },

        _createPluginOptions : function(){
                var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(this, arguments);
            if(this.model) {
                //TODO: used _getDisplayItems. Internal API
                var vItems = _.map(
                    this.model._getDisplayItems() ? this.model._getDisplayItems().moChildNodes: [],
                    function(item, index){
                        return item.value;
                    }, this);
                vOptions.values = vItems;

                if(this.model.parent && this.model.parent._isExclusionGroup()) {
                    //push atleast one of these
                    vOptions.name = this.model.parent.name+""+this.parentView._id;
                }
            }
            return vOptions;
        }
    });

    Object.defineProperty(xfalib.view.CheckButtonFieldView.prototype, "resizable", {
        get : function(){
            return false;
        },

        set : function(sValue){
            //Do Nothing
        }
    });

})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.TextFieldView = xfalib.view.FieldView.extend({
        _createPluginOptions : function() {
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(this,
                    arguments);
            vOptions.multiLine = false;
            if (this.model) {
                var ui = this.model.getElement('ui', 0, true);
                var uiChild;

                if(ui) {
                    uiChild = ui.oneOfChild;
                    if(uiChild) {
                        vOptions.multiLine = uiChild.getAttribute("multiLine") == 0 ? false : true;
                    }
                }

                var value = this.model.getElement("value", 0, true);
                if(value) {
                    var valueChild = value.oneOfChild;
                    if(valueChild) {
                        var maxChars = valueChild.getAttribute("maxChars");
                        //note : maxChars/ numberOfCells as zero should be treated as undefined/no restriction
                        vOptions.maxChars = this.getOrElse(maxChars, undefined);
                    }
                    if(valueChild.className === "exData" && valueChild.jsonModel._value !== null && valueChild.jsonModel._value.indexOf("<body xmlns=") === -1){
                        valueChild._transformToXFACompliantModel();
                        vOptions.value = valueChild.jsonModel._value;
                    }
                }

                if(!vOptions.maxChars){
                    //note : numberOfCells as zero should be treated as undefined/no restriction
                    if(uiChild) {
                        var comb = uiChild.getElement("comb", 0, true);
                        if(comb) {
                            vOptions.maxChars = comb.getAttribute('numberOfCells');
                        }
                    }
                }
                if (!vOptions.fontSize) {
                    var font = this.model.getElement("font", 0, true);
                    if (font) {
                        vOptions.fontSize = this._convertToPx(font.size);
                        vOptions.fontFamily = font.typeface;
                    }
                }
            }
            return vOptions;
        },

        _createDefaultWidgetPlugin : function(options) {
            if(this._richTextSupport()){
                $(this.widget).richTextField(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-richTextField");
            }else{
                $(this.widget).textField(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-textField");
            }
        },

        _richTextSupport: function(){
           return(this.getOrElse(this.model, "value.oneOfChild.className", null) === "exData"? true:false);
        },

        createWidgetPlugin : function(options) {
            //cm-usecase: adding class to enable rich text widget registration against the class
            if(this._richTextSupport()) {
                this.$el.addClass('richtextsupport');
        }
            xfalib.view.FieldView.prototype.createWidgetPlugin.call(this,
                options);
        },


        _getMeasurementOptions : function() {
           var measureOptions = xfalib.view.FieldView.prototype._getMeasurementOptions.apply(this, arguments);
           // adding this option to check for fields requiring rich text support.
           measureOptions.contentType = this._richTextSupport() ? "text/html":"text/plain";
           measureOptions.skipXSSProtection = $(this.widget).data('skipXSSProtection');
           return measureOptions;
        },

        _getParaStyles : function(){
            var paraStyles = {},para;
            para = this.model.getElement("para", 0, true);
            if(para){
                paraStyles = xfalib.view.FieldView.prototype._getParaStyles.apply(this, arguments);
                paraStyles['line-height']= parseFloat(para.lineHeight)>0? this._convertToPx(para.lineHeight)+"px":"normal";
            }
            return paraStyles;
        }

    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.DateTimeFieldView = xfalib.view.FieldView.extend({

        _createDefaultWidgetPlugin : function(options) {
            if (this.model /*&& xfa.host.platform !== "iPad"*/) {
                $(this.widget).dateTimeEdit(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-dateTimeEdit");
            } else {
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this,[options]);
            }
        },

        _createPluginOptions : function(){
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(this, arguments);
            if(this.model) {
                var locale = this.model.locale;
                vOptions.days = this.model._xfa()._getLocaleSymbols(locale,"calendarSymbols.abbrdayNames");
                vOptions.months = this.model._xfa()._getLocaleSymbols(locale,"calendarSymbols.monthNames");
                vOptions.zero = this.model._xfa()._getLocaleSymbols(locale,"numberSymbols.zero");
                vOptions.clearText = xfalib.locale.Strings.clearText;
                vOptions.$clickable = this.$el;
                vOptions.useNativeWidget = false;
                var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
                vOptions.showCalendarIcon = !behaviorConfig.isOn('mfDisableCalendarIcon');
                vOptions.calendarIconWidth = _.min([xfalib.template.Constants.calendarIconMaxWidth, Math.floor(vOptions.height)]) - 2;

                var editPattern = this.getOrElse(this.model, "ui.picture.value", null);
                if (editPattern) {
                    var parsedPattern = xfalib.ut.PictureUtils.parsePictureClause(editPattern);
                    if (_.isEmpty(parsedPattern) || _.isArray(parsedPattern) && parsedPattern.length > 1) {
                        editPattern = null; // for now fall back to default patterns in case of unsupported / multiple patterns
                        // TODO : make a array of the parsed objects and iter over them in abstract widget : parseEditValue
                    }
                }

                vOptions.editPattern = editPattern;
            }
            return vOptions;
        },

        handleChangeEvent: function(event) {
            //TODO: pass on the correct data
            var detail = {
                newText:null,
                keycode:null,
                modifier:null,
                keyDown:false,
                shift:false,
                change: null
            };
            this.model.execEvent("change", detail);
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.ImageFieldView = xfalib.view.FieldView.extend({

        _createDefaultWidgetPlugin : function(options) {
            $(this.widget).imageField(options);
            this.jqWidget = this.$data(this.widget, "xfaWidget-imageField");
        },

        _createPluginOptions : function() {
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(
                    this, arguments);
            var imageObj = this.getOrElse(this, "model.value.image", null);
            if (imageObj) {
                vOptions.aspect = imageObj.getAttribute("aspect");
            }
            return vOptions;
        },

        initialize : function() {
            xfalib.view.FieldView.prototype.initialize.apply(this, arguments);
        },

        handleChangeEvent : function(changeEvent) {
           this.model.execEvent("change");
           // NPR-15286 : to trigger event on formbridge whenever the value of scribble changes.
           if (this._getWidgetNameFromUiExtra() == xfalib.template.Constants.ScribbleImageField) {
               xfalib.ut.XfaUtil.prototype._triggerOnBridge(xfalib.template.Constants.scribbleChangeEvent, this.model, "change", this.model.somExpression);
           }
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.ButtonFieldView = xfalib.view.FieldView.extend({
        handleCommit : function(event){
            // xfa.Logger.debug("[ButtonFieldView.handleCommit]som" +
            // this.$el.data("som"));
            // do Nothing
        },

        handleClickEvent : function(event) {
            if(this.jqWidget.option("access") == "open") {
                xfalib.view.FieldView.prototype._setFocusParam(this);
                xfalib.view.FieldView.prototype.handleClickEvent.apply(this,arguments);
                xfalib.ut.XfaUtil.prototype._triggerOnBridge("elementButtonClicked", this.model, "click", this.model.somExpression);
            }
        },

        _handleKeyDown : function(event) {

        },

        handleDomChanged :function(event){
            switch(event._property) {
               case "caption.value.text":
                     this._handleCaptionValueChange(event.newText);
                     break;
               default:
                     xfalib.view.FieldView.prototype.handleDomChanged.apply(this,
                     arguments);
            }
        },

        _handleCaptionValueChange : function(text) {
             var  child = {};
             var caption = this.model.getElement('caption',0, true);
             var value = caption.getElement('value',0, true);

             if(value) {
                 child = value.oneOfChild;
                 if (["text","exData"].indexOf(child.className) !== -1) {
                    var cssObj = this._getTextStyle(caption);
                    if(cssObj) {
                        this.$css(this.caption, cssObj.fontStyles);
                    }
                    this.$css(this.caption, {'display':'table'}); // using this to utilise the css property vertical-align to account for vAlign
                    text=xfalib.ut.XfaUtil.prototype.encodeScriptableTags(this._convertXFARichToHtml(text));
                    $(this.caption.children[0]).replaceWith(text);
                    if(this.caption.children[0] && cssObj) {
                        this.$css(this.caption.children[0], cssObj.paraStyles);
                    }
                 }
             }
        },

        _getTextStyle : function(caption){
            var cssObj=xfalib.view.BaseView.prototype._getTextStyle.apply(this,[caption]);
            var para = caption.getElement('para',0,true);
            if(cssObj && para && para.vAlign) {
               cssObj.paraStyles['vertical-align']= para.vAlign;
               cssObj.paraStyles['display'] = 'table-cell';
            }
            return cssObj;
        },

        _createPluginOptions : function() {
            var pluginOptions = xfalib.view.FieldView.prototype._createPluginOptions.call(this);
            var paraStyles = null;
            if(this.model.getElement("caption", 0, true) && this.model.caption.getElement("para", 0, true)){
                var para = this.model.caption.para;
                paraStyles = {
                    "text-align" : para.hAlign,
                    "vertical-align" : para.vAlign,
                    "text-indent" : this._convertToPx(para.textIndent),
                    "padding-left" : this._convertToPx(para.marginLeft),
                    "padding-right" : this._convertToPx(para.marginRight),
                    "padding-top" : this._convertToPx(para.spaceAbove),
                    "padding-bottom" : this._convertToPx(para.spaceBelow)
                };
            }
            pluginOptions["paraStyles"] = paraStyles;
            pluginOptions["svgCaption"] = this.caption != null;
            return pluginOptions;
        },

        _createDefaultWidgetPlugin :  function(options){
            if(this.model){
                $(this.widget).xfaButton(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-xfaButton");
            }
            else{
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this, [options]);
            }
        }

    });
})(_, $, xfalib);(function(_, $, xfalib){
    xfalib.view.NumericFieldView = xfalib.view.FieldView.extend({
        _matchArray : { "integer":"^[+-]?\\d*$", "decimal":"^[+-]?\\dld(\\.\\dfd)?$", "float":"^[+-]?\\d*(\\.\\d*)?$" },
        _createPluginOptions : function() {
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(
                    this, arguments);
            if (this.model) {
                vOptions.dataType = this.model.value.oneOfChild.className ;
                vOptions.leadDigits = this.model.value.oneOfChild.leadDigits;
                vOptions.fracDigits = this.model.value.oneOfChild.fracDigits;
                vOptions.zero = this.model._xfa()._getLocaleSymbols(this.model.locale,"numberSymbols.zero");
                vOptions.decimal = this.model._xfa()._getLocaleSymbols(this.model.locale,"numberSymbols.decimal");
                //note : numberOfCells as zero should be treated as undefined/no restriction
                var uiChild = this.model.ui.oneOfChild;
                if(uiChild != null && uiChild.getElement("comb", 0, true) != null)
                    vOptions.combCells = this.model.ui.oneOfChild.comb.numberOfCells || undefined;
            }
            return vOptions;
        },

        _createDefaultWidgetPlugin : function(options) {
            if (this.model) {
                $(this.widget).numericInput(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-numericInput");
            } else {
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this,
                        [options]);
            }
        },

        handleCommit : function(event) {
            var _regex = null;
            var temp = this.jqWidget.option("value") + "";

            var ld = this.model.value.oneOfChild.leadDigits;
            var fd = this.model.value.oneOfChild.fracDigits;

            var matchStr = this._matchArray[this.model.value.oneOfChild.className];

            ld = (ld !== undefined && ~ld) ? "{0,"+ld+"}" : "*";
            fd = (fd !== undefined && ~fd) ? "{0,"+fd+"}" : "*";
            matchStr = matchStr.replace("ld", ld);
            matchStr = matchStr.replace("fd", fd);
            _regex = new RegExp(matchStr, "g");

            if (temp.match(_regex)) // if we need to keep this new	entered value
                xfalib.view.FieldView.prototype.handleCommit.apply(this, arguments);
            else
                 this.jqWidget.option("value",this.model[this.commitTarget]);
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.ChoiceListFieldView = xfalib.view.FieldView.extend({

        initialize: function () {
            xfalib.view.FieldView.prototype.initialize.apply(this, arguments);
            this._prevSelection = null;
        },

        _valueToArray: function(value) {
            var valueArray;
            if(value != null)
                valueArray = value.split("\n");
            else
                valueArray = [null];
            return valueArray;
        },

        _handleValueChange : function(event){
            //xfa.Logger.debug("[ChoiceListFieldView._handleValueChange]value:som" + event.newText + ":" + this.$el.data("som"));
            var prevText = this.jqWidget.option("displayValue");
            if (_.isArray(prevText)) {
                prevText = prevText.join("\n");
            }
            this._prevSelection = prevText;

            this.jqWidget.option("value",this._valueToArray(event.prevText));
            this.jqWidget.option("displayValue",this._valueToArray(event.newText));
        },

        handleCommit : function(event){
            //xfa.Logger.debug("[ChoiceListFieldView.handleCommit]som" + this.$el.data("som"));
            var val = this.jqWidget.option("value");
            if(_.isArray(val)){
                val = val.join("\n");
            }
            this.model[this.commitTarget] = val;
        },

        _createDefaultWidgetPlugin :  function(options){
            if(this.model)
            {
                if(this.model.ui.oneOfChild.open == 'always' || this.model.ui.oneOfChild.open == 'multiSelect'){
					//do role setting --
                    $(this).attr("role", "listbox"); //find a better place to do this
                    if($.browser.msie || $.browser.mozilla){
                        $(this.widget).nwkListBox(options);
                        this.jqWidget = this.$data(this.widget, "xfaWidget-nwkListBox");
                    }
                    else {
                        $(this.widget).listBox(options);
                        this.jqWidget = this.$data(this.widget, "xfaWidget-listBox");
                    }
                }
                else{
                    $(this.widget).dropDownList(options);
                    this.jqWidget = this.$data(this.widget, "xfaWidget-dropDownList");
                    if (options.access === "readOnly") {
                        var readOnlyDropDown = this.widget.getElementsByTagName("select")[0];
                        readOnlyDropDown.disabled = false;
                        readOnlyDropDown.setAttribute("aria-readonly", "true");
                        _.each(readOnlyDropDown.childNodes, function (element) {
                            element.disabled = true;
                        });
                    }
                }
            }
            else{
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this, [options]);
            }
        },

        _createPluginOptions : function(){
            var vOptions =  xfalib.view.FieldView.prototype._createPluginOptions.apply(this, arguments);
            if(vOptions.value!=null && !_.isArray(vOptions.value))
            {
                if(_.isString(vOptions.value))
                    vOptions.value = vOptions.value.split("\n");
                else
                    vOptions.value = [vOptions.value]; //convert new value to array
            }
            if(this.model)
            {
                var that = this;
                vOptions.editable =  (this.model.ui.oneOfChild.textEntry == '1');
                vOptions.multiSelect =  (this.model.ui.oneOfChild.open == 'multiSelect');
                var vItems = _.map(this.model._getDisplayItems() ? this.model._getDisplayItems().moChildNodes : [],
                    function(item, index){
                        var saveItem =  that.model.getSaveItem(index);
                        var displayItem = that.model.getDisplayItem(index);
                        return {
                            "save" : saveItem,
                            "display" : displayItem
                        };
                    }
                );
                vOptions.items = vItems;
            }
            return vOptions;
        },
        
        handleModelChanged : function(event) {
            if (event._property == "addItem") {
                this._handleAddItem(event);
            }
            if (event._property == "clearItems") {
                    this._handleClearItems(event);
            }
            if (event._property == "deleteItem") {
                this._handleDeleteItem(event);
        }
            else
                xfalib.view.FieldView.prototype.handleModelChanged.apply(this,
                        arguments);
        },

        handleChangeEvent : function(event) {
            var newValue =  this.jqWidget.option("displayValue");
            if(_.isArray(newValue)) {
                newValue = newValue.join("\n"); // return a string
            }
            var detail = {
                newText:newValue,
                prevText: this._prevSelection,
                keycode:event.which,
                modifier:event.ctrlKey,
                keyDown:event.which===40,
                shift:event.shiftKey,
                change: newValue
            };
            this.model.execEvent("change", detail);
        },
        
        _handleAddItem : function(event) {
        	var itemValues = {
        			sDisplayVal:event.newText,
        			sSaveVal:event.prevText
                };
        	this.jqWidget.addItem(itemValues);
            },
        
        _handleClearItems : function(event) {
        	this.jqWidget.clearItems();
            },
                   
        _handleDeleteItem : function(event) {
        	this.jqWidget.deleteItem(event.newText);
        }

    });
})(_, $, xfalib);
(function(_, $, xfalib){

    xfalib.view.ContainerView = xfalib.view.BaseView.extend({
        initialize : function() {
            xfalib.view.BaseView.prototype.initialize.apply(this, arguments);
            this.layoutTemplate = {};
            this.childViews = [];
            this.layout = null;
            this._initLayout();
        },

        _initLayout : function(){
            xfalib.view.BaseView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                this._processLayoutTemplate();
                this.layout = this._layoutManager.createLayout(this);
                if (this.model) {
                    this.model.on(xfalib.script.XfaModelEvent.CHILD_ADDED,this);
                    this.model.on(xfalib.script.XfaModelEvent.CHILD_REMOVED,this);
                    this.model.on(xfalib.script.XfaModelEvent.CHILD_MOVED,this);
                }
                this._syncFormNodeToHtml(true);
            }
        },

        _processLayoutTemplate : function(){
            var xfaTemplateCache = this._formDomRoot()._xfaTemplateCache;
            var htmlTemplateCache = this._xfaViewRegistry().templateCache();
            var that = this;
            var initialFormNode = xfaTemplateCache.getInitialFormDomRef(this._id);
            if(!initialFormNode){
                this.layoutTemplate.hasTemplate = false;
                return;
            } else
                this.layoutTemplate.hasTemplate = true;

            this.$elchildren().each(function() {
                var iChildNode = xfaTemplateCache.getInitialFormDomRef(this.id);
                if(!iChildNode)
                    return;

                var partBegin = true,
                    partSplit = false,
                    partEnd = true;
                var occurrences = that.getOrElse(that.$data(this, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL+"."+xfalib.view.LayoutConst.OCCURRENCES, 1); //occurrences
                var currentOccurence = that.getOrElse(that.$data(this, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL+"."+xfalib.view.LayoutConst.OCCUR_INDEX, 0); //occurIndex
                if(currentOccurence != 0){
                    //The part has been split and currentOccurance is not zero. That means this element does not start in the parent layout.
                    partBegin = false; // not really used anywhere
                }
                if((occurrences - currentOccurence) > 1){
                    //This means that this element layout has been split into multiple parts and this part is not last part.
                    partSplit = true;
                    partEnd = false;
                }
                var childTemplateId = xfaTemplateCache.getTemplateRef(iChildNode.extras.htmlId).extras.htmlId;
                that.$data(this, "templateId", childTemplateId); // Set the templateId as actual id may change.
                if(xfalib.ut.XfaUtil.prototype.isTableHF(iChildNode)){
                    //A super hack for #3468407 till we support leader/trailer. For Table Header/Footer we may not have IM before it. So handle exclusively till we fix it
                    that.layoutTemplate[iChildNode.extras.htmlId] = {hasFirstPartBegin : partBegin, hasLastPartOverflow : partSplit};
                }
                else if(iChildNode && that.getOrElse(that.$data(this, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.NODE_TYPE ,"").toLowerCase() == "subform"){
                    var instanceIndex = -1;
                    var sfIM = null;
                    var found = _.find(initialFormNode.children, function(initChild){
                        if(that.matchJsonType(initChild, "instanceManager")){
                            sfIM = initChild;
                            instanceIndex = -1;
                            return false;
                        }
                        else {
                            instanceIndex = instanceIndex + 1;
                            if(initChild == iChildNode)
                                return true;
                            else
                                return false;
                        }
                    });
                    if(found){
                        // if repeatable put in cache, along with current occurIndex for later stitching
                        if(iChildNode.extras.htmlId == childTemplateId && sfIM && (parseInt(that.getOrElse(sfIM.max, xfalib.script.Occur.prototype._defaults.max)) < 0 ||
                            parseInt(that.getOrElse(sfIM.min, xfalib.script.Occur.prototype._defaults.min )) < parseInt(that.getOrElse(sfIM.max, xfalib.script.Occur.prototype._defaults.max )))){
                            htmlTemplateCache.put(this.cloneNode(true));
                        }
                        var isLastChild = true;
                        var childIndex = initialFormNode.children.indexOf(iChildNode);
                        if(initialFormNode.children.length > childIndex +1 &&
                            that.matchJsonType(initialFormNode.children[childIndex + 1], "subform")){
                            isLastChild = false;
                        }
                        instanceIndex = instanceIndex + currentOccurence/1000;  // hack, assume at most 1000 instances of a rpt. SF.
                                                                               // the decimal part is used to judge the overflowed part which has split over multiple pages
                        that.layoutTemplate[childTemplateId] = !_.isEmpty(that.layoutTemplate[childTemplateId]) ? that.layoutTemplate[childTemplateId] : {
                            id: childTemplateId,
                            start : instanceIndex,
                            end : instanceIndex,
                            hasFirstPartBegin : partBegin,
                            hasLastPartOverflow : partSplit
                        };
                        that.layoutTemplate[childTemplateId].end = isLastChild && partEnd ? -1 : instanceIndex;
                        that.layoutTemplate[childTemplateId].hasLastPartOverflow = partSplit;
                    }
                } else {
                    that.layoutTemplate[childTemplateId] = {hasFirstPartBegin : partBegin, hasLastPartOverflow : partSplit};
                }
            }) ;
        },

        _syncFormNodeToHtml: function(deepSync){
            var that = this;
            var htmlTemplateCache = this._xfaViewRegistry().templateCache();
            var oldIdToChildViews = {};
            var newIdToChildViews = {};
            var cellIndex = 0;
            var lastSibling = null;

            //cache the old child views against their IDs
            _.each(this.childViews, function(childView){
                oldIdToChildViews[childView.el.id] = childView;
            }, this);

            _.each(this.getOrElse(this, "model.children", []),
                function(childModel){
                    if(!this._validateLayoutTemplate(childModel))
                        return;
                    var cTemplateId = childModel._templateId();
                    var id = childModel.htmlId;
                    var childEl = this.$elchildren(that.jqId(id))[0];
                    if(!childEl && (!newIdToChildViews.hasOwnProperty(cTemplateId) && !oldIdToChildViews.hasOwnProperty(cTemplateId))){
                        childEl = this.$elchildren(that.jqId(cTemplateId))[0];
                    }
                    if(!childEl){
                        if(!this._isHidden(childModel)){
                            var htmlTmplt = htmlTemplateCache.get(cTemplateId, true);
                            if(!htmlTmplt){
                                xfalib.runtime.xfa.Logger.error("xfaView", "Html template could not be found. cTemplateId:"+cTemplateId+", som:"+childModel.somExpression);
                                return;
                            }
                            else{
                                childEl = htmlTmplt;
                            }
                        }
                        else {
                            var xfaHiddenPH = $("<div></div>");
                            if(childModel instanceof xfalib.script.Draw){
                                xfaHiddenPH.addClass("draw");
                            }
                            else if(childModel instanceof xfalib.script.Field){
                                xfaHiddenPH.addClass("field");
                            }
                            childEl = xfaHiddenPH.get(0);
                            //TODO: below way of finding nodetype is not always true and may break hidden objects. We will need robust way to get node type that can be used by XfaViewRegistry.nodeTyperegistry.
                            //But for current implementation it would work as we care only about container node types.
                            var elNodeType = childModel.className.toLowerCase();
                            this.$data(childEl, "xfaHiddenPH", true);
                            var xfaModelObj = {};
                            xfaModelObj[xfalib.view.LayoutConst.NODE_TYPE] = elNodeType;
                            this.$data(childEl, xfalib.view.LayoutConst.XFA_MODEL, xfaModelObj);
                        }
                    }
                    childEl.id = childModel.htmlId;

                    this.$data(childEl,"templateId", cTemplateId); //Required for nested template ELs
                    var view = null;
                    if(oldIdToChildViews.hasOwnProperty(childEl.id)) {
                        view = oldIdToChildViews[childEl.id];
                        if(lastSibling && lastSibling.model instanceof xfalib.script.Subform && lastSibling.model.instanceManager._isRepeatable())
                            lastSibling.$el.after(view.$el); //The repeatable subform might have moved using moveInstance. So position it after it's sibling.
                        if(deepSync)
                            view.syncFormNodeToHtml(deepSync); //Sync existing views only if deepSync is requested
                    } else {
                        view = this._createChild(childEl, cellIndex, lastSibling);
                    }
                    cellIndex = cellIndex + (view.layoutModel.colspan || 1); //Add the colspan or one
                    newIdToChildViews[childModel.htmlId] = view;
                    lastSibling = view;
                }, this
            );

            this.childViews = [];
            if (!this.$el.is(":empty")) {
                this.$elchildren().each(function() {
                    if(newIdToChildViews.hasOwnProperty(this.id))
                        that.childViews.push(newIdToChildViews[this.id]);
                    else {
                         xfalib.runtime.xfa.Logger.log("xfaView",5,"removing element as no corresponding form dom node found. id:" + this.id + ", parent id:"+ that._id);
                        $(this).remove();
                    }
                }) ;
            }
            xfalib.view.BaseView.prototype._syncFormNodeToHtml.apply(this, arguments);   //sync other props before layout
        },

        _createChild : function(childEl, cellIndex, previousSibling){
            var view = this._xfaViewRegistry().createView(childEl, {
                    parentView: this,
                    tableCellIndex : cellIndex,
                    pageNumber: this._pageNumber()
                });
//            if(this.resizable || view._isPlaceHolderEl()){
//                //We also need to call layoutContainer for the cases where the object is initially hidden even if parent is not resizable
//                // since we do not have el for hidden object as yet,. TODO: optimize it.
//                view.on(xfalib.view.XfaViewEvent.EXTENT_CHANGE +" "+ window.xfalib.view.XfaViewEvent.PRESENCE_CHANGE,
//                    this._layoutContainer, this);
//            }
            if(this.$el.find(view.$el).length < 1){
                if(previousSibling)
                    previousSibling.$el.after(view.$el);        //Push the element after the sibling
                else
                    this.$el.prepend(view.$el);      //push the element at the begining of parent if no sibling is found,\.
            }
            return view;
        },

        _validateLayoutTemplate : function(childModel){
            var cTemplateId = childModel._templateId();
            if(xfalib.ut.XfaUtil.prototype.isTableHF(childModel)){
                //A super hack for #3468407 till we support leader/trailer. For table Header/Footer, templateId would be this same htmlId.
                cTemplateId = childModel.htmlId;
            }
            if(!this._isPaintable(childModel))
                return false;
            if(this.layoutTemplate.hasTemplate){
                var xfaTemplateCache = this._formDomRoot()._xfaTemplateCache;
                var iChildJson = xfaTemplateCache.getInitialFormDomRef(childModel.htmlId); //find the t0 version of this child
                if(!this.layoutTemplate.hasOwnProperty(cTemplateId) && !this._isHidden(iChildJson))
                    return false; // Here because the page has been split and this childModel is rendered in different page
                else if(!this.layoutTemplate.hasOwnProperty(cTemplateId) && this._isHidden(iChildJson)){
                    //if this child may not present in layout template if it was hidden at t0 becase for hidden containers layout is not generated.
                    //So we need to put extra effort to check if this hidden object fits layout template of this view.
                    var valid = this._validateHiddenChildLayout(childModel);
                    if(valid){
                        //if found validated, cache it for future. Also hidden part are automatically stitched into one part, so hasLastPartOverflow would false
                        this.layoutTemplate[cTemplateId] = {hasFirstPartBegin: true, hasLastPartOverflow : false};
                    }
                    return valid;
                }
                else if(childModel instanceof xfalib.script.Subform &&
                    (childModel.instanceIndex < Math.floor(this.layoutTemplate[cTemplateId].start) ||
                    (childModel.instanceIndex > this.layoutTemplate[cTemplateId].end && this.layoutTemplate[cTemplateId].end > -1))){
                    return false;   //This subform is not in the range of Instances handled by this page. Lying either in earlier or next pages.
                }
            }
            return true;
        },

        _validateHiddenChildLayout : function(childModel){
            if(!childModel.parent)
                return false;       //can happen only for rootsubformview as child model
            var siblings = childModel.parent.children;
            if(siblings && siblings.indexOf(childModel) > 0){
                var childIndex = siblings.indexOf(childModel);
                var lastPaintableSibling = null;
                for(var lastIndex = childIndex-1; lastIndex >=0; lastIndex--){
                    var lastSibling = siblings[lastIndex];
                    if(lastSibling instanceof xfalib.script.InstanceManager){
                        var instanceTemplate = lastSibling._instanceTemplate();
                        var templateId = this.getOrElse(instanceTemplate, "extras.htmlId", null);
                        if(this.layoutTemplate[templateId] != null){
                            if(this.layoutTemplate[templateId].end == -1 && !this.layoutTemplate[templateId].hasLastPartOverflow){
                                //Last layout part of last instance of this IM was here at t0.
                                //So hidden object should come on this page. Else on another page.
                                return true;
                            }
                            else
                                return false;
                        }
                        else
                            continue;   //IM of this hidden sf?.
                    }
                    else if(!this._isPaintable(lastSibling)){
                        continue;
                    }
                    else{
                        lastPaintableSibling = lastSibling;
                        break;
                    }
                }
                if(!lastPaintableSibling){
                    //This hidden child model is first paintable child of this. If this layout element is first part of this model layout
                    // Then hidden child should be painted in this page/view. Else in other view.
                    if(this.getOrElse(this.layoutModel, "occurIndex", 0) == 0)
                        return true;
                    else
                        return false;
                }
                else {
                    //Else if *last part of last paintable sibling* of this hidden node belong to this layout template then this hidden node would also belong here.
                    var lastSiblingValid = this._validateLayoutTemplate(lastPaintableSibling);
                    if(lastSiblingValid){
                        var lastSiblingTemplateId = lastPaintableSibling._templateId();
                        if(!this.layoutTemplate[lastSiblingTemplateId].hasLastPartOverflow)
                            return true;
                        else
                            return false;
                    }
                    else{
                        return false;
                    }
                }
            }
        },

        handleEvent: function(evnt) {
            switch(evnt.name) {
                case xfalib.script.XfaModelEvent.CHILD_ADDED:
                    this.handleChildAdded(evnt);
                    break;
                case xfalib.script.XfaModelEvent.CHILD_REMOVED:
                    this.handleChildRemoved(evnt);
                    break;
                case xfalib.script.XfaModelEvent.CHILD_MOVED:
                    this.handleChildMoved(evnt);
                    break;
                default:
                    xfalib.view.BaseView.prototype.handleEvent.apply(this, arguments);
            }
        },

        handleDomChanged :function(event){
            switch(event._property) {
                default:
                    xfalib.view.BaseView.prototype.handleDomChanged.apply(this,
                        arguments);
            }
        },

        handleModelChanged : function(event) {
            if (event._property == "fillColor") {
                this._fillColor(event.newText);
            }
            else if (event._property == "borderColor") {
                this._borderColor(event.newText);
            }
            /*else if (event._property == "borderWidth") {
                this._borderWidth(event.newText);
            }     */
            else
                xfalib.view.BaseView.prototype.handleModelChanged.apply(this,
                    arguments);
        },

        /*_borderWidth : function(width) {
            $(this.el).css("borderWidth", width)
        },          */

        handleChildAdded : function(event) {
            var addedChild  = event.newText;
            var childTemplateId = addedChild._templateId();
            if(!this.layoutTemplate.hasTemplate || (this.layoutTemplate.hasOwnProperty(childTemplateId) && addedChild.instanceIndex >=  this.layoutTemplate[childTemplateId].start &&
                (this.layoutTemplate[childTemplateId].end < 0 || addedChild.instanceIndex <= this.layoutTemplate[childTemplateId].end))){
                //If added child resides in the range supported by this view, sync it.
                this._syncFormNodeToHtml(false);
            }
            else
                xfalib.runtime.xfa.Logger.debug( "xfaView","This instanceManager has no child in this layout template. This would be handled in other part of splitted subform. el id:"+this._id);
        },

        handleChildMoved : function(event) {
            this._syncFormNodeToHtml(true);
        },

        handleChildRemoved : function(event) {
            var removedChild = event.prevText;
            /*
             * Note/Hack: To get the templateId of removedChild, we can not simply ask child._templateId() as this would return template Id of only those
              * nodes which are still connected to xfa dom. Since remove child is disconnected from xfa, we are asking template Id of this from it's instanceManage
              * which is still there. A workaround for now.
             */
            var childTemplateId = removedChild.instanceManager._instanceTemplate().extras.htmlId;
            if(!this.layoutTemplate.hasTemplate || (this.layoutTemplate.hasOwnProperty(childTemplateId) &&
                (this.layoutTemplate[childTemplateId].end < 0 || removedChild.instanceIndex <= this.layoutTemplate[childTemplateId].end))){
                //If the removed child has instanceIndex less than the end range then there is potential for relayout of this page. So syn it.
                this._syncFormNodeToHtml(false);
            }
            else
                xfalib.runtime.xfa.Logger.debug( "xfaView","This instanceManager has no child in this layout template. This would be handled in other part of splitted subform. el id:"+this._id);
        },

        destroy : function() {
          //TODO: Implement and call destroy method
        },

        _isAnonymous : function() {
            return false;
        },

        _normalizedChildViews : function() {
            var normalizedChildViews = [];
            _.foldl(this.childViews, function(memo, childView, index){
                if(childView instanceof xfalib.view.ContainerView && childView._isAnonymous()){
                    _.each(childView._normalizedChildViews(), function(normalizedChild){
                        memo.push(normalizedChild);
                    });
                }
                else if(!this._isHidden(childView.model)){
                    memo.push(childView);
                }
                return memo;
            }, normalizedChildViews, this);
            return normalizedChildViews;
        },

        _isHidden : function(model){
            //model can be a Node object or simply a json
            if(model && (model.presence == "hidden" || model.presence == "inactive"))
                return true;
            else
                return false;
        },

        _isPaintable : function(model){
            //can this model have visual representation
            if(model && model.isContainer && model.className != "variables")
                return true;
            else
                return false;
        },

        measureSize : function(){
            if(this.layout)
                return this.layout.measureSize();
            else
                return false;
        },

        invalidateSize : function(){
            if(this.layout)
                return this.layout.invalidateSize();
        },

        updateDisplay : function(){
            if(this.layout)
                return this.layout.updateDisplay();
        },

        $elchildren : function(id) {
            return this.$el.children(id);
        }


    });
})(_, $, xfalib);
(function(_, $, xfalib){
    //Intermediate hierarchy to extract out common code for PageView/ContentAreaView/RootSubformView
    xfalib.view.LayoutContainerView = xfalib.view.ContainerView.extend({
        initialize : function(){
            this.growableView = []; // Element that can grow beyond boundary. Current assumption is that there can be only one such element in ContentArea/PageArea
            xfalib.view.ContainerView.prototype.initialize.apply(this, arguments);
        },

        _syncFormNodeToHtml: function(deepSync){
            if(this.childViews == null || this.childViews.length == 0){
                this.childViews = [];
                var that = this;
                var cellIndex = 0;
                if (!this.$el.is(":empty")) {
                    this.childViews = this.$el.children().map(function() {
                        var childView = that._xfaViewRegistry().createView(this, {
                            parentView: that,
                            tableCellIndex : cellIndex,
                            pageNumber: that._pageNumber()
                        });
                        cellIndex = cellIndex + (childView.layoutModel.colspan || 1); //Add the colspan or one
                        if(that._isGrowableView(childView)) {
                            that.growableView.push(childView);
                        }
                        return childView;
                    }).get();
                }
            } else {
                _.each(this.childViews, function(childView){
                    childView.syncFormNodeToHtml(deepSync);
                }, this);
            }
            xfalib.view.BaseView.prototype._syncFormNodeToHtml.apply(this, arguments);   //sync other props before layput
        },

        _isGrowableView :function(childView){
            return false;
        },

        _forceView: function() {
            //this function is to dictate whether the view is forced
            //will be used to force the render of first page at least.
            return false;
        }

    });
})(_, $, xfalib);

(function(_, $, xfalib){
    var SubformView = xfalib.view.SubformView = xfalib.view.ContainerView.extend({

        _assignToolTip: function () {
            var toolTipText = xfalib.ut.XfaUtil.prototype._getToolTipText(this.model);
            // CQ-4222981 : assign tooltip for subform having role as table or it is table
            if (toolTipText && xfalib.ut.XfaUtil.prototype._tableCheckForAccessibility(this)) {
                this.$el.attr("title", toolTipText);
            }
        }

    });

    Object.defineProperty(SubformView.prototype, "resizable", {
        get : function(){
            if(this._resizable)
                return true;
            var layout = this.layoutModel.layout;
            if(layout == xfalib.view.LayoutConst.LAYOUT_LEFTRIGHTTOPBOTTOM || layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTTOPBOTTOM || layout == xfalib.view.LayoutConst.LAYOUT_TOPBOTTOM)
                return true;
            else
                return false;
        },

        set : function(sValue){
            this._resizable = sValue;
        }
    });

})(_, $, xfalib);(function(_, $, xfalib){
    var SubformSetView = xfalib.view.SubformSetView = xfalib.view.ContainerView.extend({
        initialize : function() {
            xfalib.view.ContainerView.prototype.initialize.apply(this, arguments);
        },

        _isAnonymous : function() {
            return true;
        },

        $computeWH : function(){
            var extent = {};
            return extent;
        },

        _computeExtent : function() {
            //mark the position of the subformset as transparent
            var extent = xfalib.view.ContainerView.prototype._computeExtent.apply(this, arguments);
            extent['position'] = 'static';
            return extent
        }
    });
})(_, $, xfalib);(function(_, $, xfalib){
    xfalib.view.ContentAreaView = xfalib.view.LayoutContainerView.extend({
        _isGrowableView :function(childView){
            return (childView.model === this._formDomRoot().form.children[0]); // Is root subform of the form dom
        },

        _initializeLayoutModel : function(){
            xfalib.view.LayoutContainerView.prototype._initializeLayoutModel.apply(this, arguments);
            //Special handling for enabling shrink page functionality. We'll treat contentArea as TopBotton flowable subform.Bug#3608773
            this.layoutModel.extentactualh = -1;
            this.resizable = true;
        }

    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.PageView = xfalib.view.LayoutContainerView.extend({

        initialize : function() {
            xfalib.view.LayoutContainerView.prototype.initialize.apply(this, arguments);
            /* Flag indicating that the tabbing computation for this Page would be redone */
            this._tabComputePending = false;
        },

        _initLayout : function(){
            xfalib.view.LayoutContainerView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                /* When a Page View is initialized, immediately mark it for tab compute*/
                this.invalidateTabIndex();
            }
        },

        _forceView: function() {
            //this function is to dictate whether the view is forced
            //will be used to force the render of first page at least.
            return this._pageNumber() == 1;
        },

        _isGrowableView :function(childView){
            return (childView instanceof xfalib.view.ContentAreaView);
        },

        _pageNumber : function(){
            /* Return the page number that was sent from server. Page Number starts with 1.*/
            if(this.layoutModel){
                return this.layoutModel.pageNumber;
            }
            return -1;
        },

        _computeExtent : function(){
            var extent = xfalib.view.LayoutContainerView.prototype._computeExtent.apply(this, arguments);
            extent["position"] = "relative";
            extent["margin-left"] = "auto";               //We need to mark page margins to auto to adjust pages with different master page layout
            extent["margin-right"] = "auto";
            extent["margin-bottom"] = 10;
            extent["margin-top"] = this._pageNumber() == 1 ? 0 : 10 ;
            return extent;
        },

        /*
         * Marks/Queues the Page for re-compute of tab indexes. Re-computation would automatically be fired
         * asynchronously.
         */
        invalidateTabIndex : function(forceCompute) {
            if(!this._tabComputePending || forceCompute){
                /*
                 * Tab compute invalidation sets the tabComputePending flag to true and then fires actual computation async
                 * way in-order for cases where simultaneous in-validations may occur multiple times for different
                 * fields or repeatable subform of the same page. In those cases, we want to compute tab indexes only once when
                 * everything is done.
                 * Another thing, if there is any layout computation pending in layout manager, we defer the tab computation till
                 * that is complete since x,y can change in those cases.
                 **/
                this._tabComputePending = true;
                var that = this;
                xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(
                    window.setTimeout(function(){
                        if(!that._layoutManager.isLayoutCycleComplete()){
                            //layout cycle running so do a force invalidation to defer tab computation to next cycle
                            that.invalidateTabIndex(true);
                        }
                        else{
                            that._computeTabIndex();
                        }
                    }, 1)
                );
            }
        },

        _computeTabIndex : function () {
            this._tabComputePending = false;
            xfalib.view.util.traversalManager._computTabIndex(this);
        }

    });
})(_, $, xfalib);
(function (_, $, xfalib) {
    xfalib.view.RootSubformView = xfalib.view.LayoutContainerView.extend({
        initialize: function () {
            var pagingConfig = this._xfaViewRegistry().pagingConfig();
            this.$el = (this.options.el instanceof $) ? this.options.el : $(this.options.el);
            //make paging default
            if (pagingConfig.pagingDisabled) {
                _.each(this.options.restOfThePages, function (pageEl) {
                    // removed creation of extra page view as childView, on containerView initialize we anyways initialize childView as empty array
                    // on syncFormNodeToHtml we are using $el.children() to create new child views
                    // so just appending rest of the pages element should be enough
                    this.$el.append(pageEl);
                }, this);

            }
            else if (this.options && this.options.restOfThePages) {
                //do nothing, just mark rest of the pages as deferred pages
                this._deferredPages = this.options.restOfThePages;
            }

            this.totPages = this.getOrElse(this, "options.restOfThePages.length", 0) + 1;  // todo: fix this when initial count is present
//            console.profile("P1");
            xfalib.view.LayoutContainerView.prototype.initialize.apply(this, arguments);
//            console.profileEnd();

            //Bug#3670373: a custom event is triggered after the first page is loaded.
            var _triggerXfaFirstPgLayoutComplete = function () {
                this.childViews[0].off('layoutComplete', _triggerXfaFirstPgLayoutComplete);
                $(window).trigger('xfaFirstPgLayoutComplete');
                this._xfaViewRegistry().scaleForm();
            };
            this.childViews[0].on('layoutComplete', _triggerXfaFirstPgLayoutComplete, this);

            //accessibility
            //add form role to rootSubformView
            this.$el.attr("role", "form");

            //also add lang attribute in it
            //leap of faith -- getting the rootsubform of the form model and then set the lang attribute
            if (xfalib.runtime.form.children[0] && xfalib.runtime.form.children[0].jsonModel && xfalib.runtime.form.children[0].locale) {
                //add lang parameter
                var lang = this._langFromLocale(xfalib.runtime.form.children[0].locale);

                if (lang && lang.length > 0) {
                    this.$el.attr("lang", lang);
                }
            }

        },

        _computeExtent: function () {
            return {};
        },

        renderDeferredPage: function () {
            //assert(userConfig && userConfig.pagingConfig && userConfig.pagingConfig.pagingEnabled);
            if (this.hasMoreDeferredPages()) {                              //just make sure we have more than 10 bytes
                //create dom here
                var nextPageEl = $(this._deferredPages.shift());
                var nextPageView = this._xfaViewRegistry().createView(nextPageEl, {parentView: this});
                this.$el.append(nextPageEl);
                this.childViews = this.childViews || [];
                this.childViews.push(nextPageView);
                xfalib.ut.XfaUtil.prototype._triggerOnBridge("elementPageRendered", xfalib.runtime.xfa.form.form1, "nextPage", this.childViews.length-1, this.childViews.length);
                //this.childViews.length-1 is the page number till which form is already rendered
                //this.childViews.length indicates the page number of current page rendered
                //if(window.highlight)
                //    highlightFields();
                return nextPageView;
            }
            return null;
        },

        hasMoreDeferredPages: function () {
            return (this.getOrElse(this._deferredPages, []).length > 0);
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.ExclGroupView = xfalib.view.ContainerView.extend({
        initialize : function(){
            xfalib.view.ContainerView.prototype.initialize.apply(this, arguments);
            $(this.$el).on(xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT,
                                         $.proxy(this.handleClickEvent,this));
        },

        handleClickEvent : function() {
            //this.model.execEvent("click");
        },

        _getScreenReaderText : xfalib.view.FieldView.prototype._getScreenReaderText,

        _assignToolTip : xfalib.view.FieldView.prototype._assignToolTip,

        _initLayout : function(){
            xfalib.view.ContainerView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                this.markMandatory();
                this.$el.attr("role", "radiogroup"); //add role
            }
        },

        markMandatory : function(){
            if(this.model.mandatory== "error")
                if(this.$el)
                    this.$el.attr("data-mandatory", "true") ;
        },

        handleModelChanged : function(event) {
            switch (event._property) {
                case "focus":
                    var childView = this._getChildToFocus();
                    this._focusWidget(childView);
                    break;
                case "ValidationState":
                    this._markError(event);
                    break;
                case "ClearError":
                    this._clearError(event);
                    break;
                default:
                    xfalib.view.ContainerView.prototype.handleModelChanged.apply(this, arguments);
            }
        },

        handleDomChanged: function (event) {
            switch (event._property) {
                case "nullTest":
                    xfalib.view.FieldView.prototype._handleNullTest.call(this, event, this.$el.closest('.exclgroup'));
                    break;
                default:
                    xfalib.view.ContainerView.prototype.handleDomChanged.apply(this, arguments);
            }
        },

        _handleMandatory: xfalib.view.FieldView.prototype._handleMandatory,
        _handleDisabled: xfalib.view.FieldView.prototype._handleDisabled,

        _markError : function(evnt) {
            this.$el.addClass("widgetError");
        },

        _clearError : function(evnt) {
            this.$el.removeClass("widgetError");
        },

        /*
         * @function
         * get child view of exclusion group which needs to be focussed.
         */
        _getChildToFocus : function () {
            return _.find(this.childViews, function (childView) {
                var model = childView.model;
                return (model && model.presence == "visible" && model.mEffectiveAccess == "open");
            });
        }
    });
})(_, $, xfalib);
/**
 * Created with IntelliJ IDEA.
 * User: rpandey
 * Date: 12/24/12
 * Time: 8:14 PM
 * To change this template use File | Settings | File Templates.
 */
(function(_, $, xfalib){
    xfalib.view.SignatureFieldView = xfalib.view.FieldView.extend({
        _createPluginOptions : function() {
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(this,
                arguments);
            return vOptions;
        },

        _createDefaultWidgetPlugin : function(options) {
            $(this.widget).signatureField(options);
            this.jqWidget = this.$data(this.widget, "xfaWidget-signatureField");
        }

    });
})(_, $, xfalib);(function (_, $, xfalib) {

    xfalib.view.PagingManager = xfalib.view.ObjectView.extend({

        initialize: function () {
            xfalib.view.ObjectView.prototype.initialize.call(this);
            this.autoRenderPageHandler = null;
            this._autoPageRenderPending = false;
        },

        renderNextPage: function () {
            var that = this;
            var pageView = this._getRootView().renderDeferredPage();
            if (pageView) {
                pageView.on("layoutComplete",
                    function (event) {
                        that.trigger("newPageRender");
                        this._xfaViewRegistry().scaleForm();
                    }
                );
            }
            return pageView;

        },

        autoRenderPage: function () {
            if (this.autoRenderPageHandler) {
                //Ideally autoRenderPageHandler should be postponed till all running layout/display validation cycles are finished and
                //there is no pending layout validation. For now we are doing it in next script cycle/setTimeout.
                var autoRenderHandler = this.autoRenderPageHandler;
                xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(window.setTimeout(autoRenderHandler, 1));
                this._autoPageRenderPending = false;
            }
            else {
                this._autoPageRenderPending = true;
            }
        },

        setAutoRenderPageHandler: function (value) {
            if (this.autoRenderPageHandler != value) {
                this.autoRenderPageHandler = value;
                if (this.autoRenderPageHandler && this._autoPageRenderPending) {
                    this.autoRenderPage();
                }
            }
        },

        hasMorePages: function () {
            return this._getRootView().hasMoreDeferredPages();
        },

        _getRootView: function () {
            return this._xfaViewRegistry().rootSubformView;
        },

        pageCount: function () {
            return (this._getRootView().totPages || 1);
        },

        _makePage: function (pageNum) {
            if (pageNum > this.pageCount()) {
                pageNum = this.pageCount();
            }
            if (pageNum > this.currentPage()) {
                var extPageCounts = pageNum - this.currentPage();
                for (var i = 0; i < extPageCounts; i++) {
                    this.renderNextPage();
                }
            }
            return true;
        },

        currentPage: function () {
            var b = this._getRootView().childViews;
            if (xfalib.view.FieldView.prototype.currentFocus) {
                var a = $(xfalib.view.FieldView.prototype.currentFocus.el).parents(".page")[0];
                //TODO: Try to do without for Loop
                for (var i = 0; i < b.length; i++)
                    if (b[i].el == a)
                        return i;
            }
            return 0;
        },

        pageDown: function () {
            if (this._getRootView().hasMoreDeferredPages()) {
                var pageView = this.renderNextPage();
                this._pageDown(pageView);

            }
            else
                this._pageDown();


        },


        _pageDown: function (pageView) {
            var nextPage = this.currentPage() + 1;
            var a = $($(".page")[nextPage]);
            window.scrollTo(0, a.offset().top);
            pageView.off("layoutComplete",
                function (event) {
                    that._pageDown();
                }
            );
        },

        _makePageForHtmlId: function (htmlId, callback, context) {
            if (htmlId == null)
                return false;
            var nodeSelector = this.jqId(htmlId);
            var rootView = this._getRootView();
            var nodeElArray = rootView.$el.find(nodeSelector);
            if (nodeElArray.length > 0) {
                if (callback)
                    callback.apply(context);
                return true;
            }


            var pageFound = false;
            while (this.hasMorePages()) {
                var view = rootView.renderDeferredPage();
                if (view.$el.find(nodeSelector).length > 0) {
                    if (callback)
//LC-4424 We are sending the event layoutComplete that the layout is complete from our view point but the
// browser has not yet painted the page( Chrome) and hence the focus is coming at the wrong place.
                        view.on("layoutComplete", function () {
                            xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(
                                window.setTimeout(function () {
                                    callback.apply(context);
                                })
                            );
                        });
                    pageFound = true;
                    break;
                }
            }
            if (pageFound)
                return true;
            else
                return false;
        },

        findPage: function (htmlId) {
            if (htmlId == null)
                return false;
            var nodeSelector = this.jqId(htmlId);
            var rootView = this._getRootView();
            var i = 0;
            for (; i < rootView.childViews.length; i++) {
                var nodeElArray = $(rootView.childViews[i].el).find(nodeSelector);
                if (nodeElArray.length > 0) {
                    return i;
                }
            }
            while (this.hasMorePages()) {
                rootView.renderDeferredPage();
                var nodeElArray = $(rootView.childViews[i].el).find(nodeSelector);
                if (nodeElArray.length > 0) {
                    return i;
                }
                i++;
            }
        },

        getLayout: function (htmlId) {
            if (htmlId == null)
                return false;
            var nodeSelector = this.jqId(htmlId);
            var rootView = this._getRootView();
            var el = rootView.$el.find(nodeSelector);
            if (el.get(0)) {
                var layout = this.getOrElse(this.$data(el.get(0), "xfaView"), {});
                return layout.layoutModel;
            }
            else return null;

        },

        _pageContent: function (pageNum, className, bPageArea) {
            bPageArea = bPageArea || false;
            this._makePage(pageNum);
            var pageView = this._getRootView().childViews[pageNum];
            var contentList = new xfalib.script.XfaList();
            if (pageView.model && (!className || className == "pageArea")) {
                contentList._append(pageView.model);
            }
            if (!bPageArea) {
                for (var pv in pageView.childViews) {
                    if (pageView.childViews[pv] instanceof  xfalib.view.ContentAreaView) {
                        contentList._concat(this.$pageContent(pageView.childViews[pv], className, bPageArea));   //Rather than passing the pageArea, we are passing only contentArea
                        // so that it returns all non-pageArea content nodes
                    }

                }
                return contentList;
            }
            contentList._concat(this.$pageContent(pageView, className, bPageArea));
            return contentList;
        },

        $nodeContent: function (node, className, bPageArea) {
            //process child nodes
            var contentList = new xfalib.script.XfaList();
            if (node) {
                _.each(node.children, function (nodeChild) {
                    if (!className && nodeChild.isContainer) {
                        contentList._append(nodeChild);
                    }
                    else if (nodeChild.className == className) {
                        contentList._append(nodeChild);
                    }

                    if (nodeChild.isContainer) {
                        var nodeChildContentList = this.$nodeContent(nodeChild, className, bPageArea);
                        contentList._concat(nodeChildContentList);
                    }
                }, this);
            }
            return contentList;
        },

        $pageContent: function (view, className, bPageArea) {

            var contentList = new xfalib.script.XfaList();
            //process child nodes
            if (bPageArea && view instanceof xfalib.view.ContentAreaView)
                return contentList;      // Breaking the recursion here, so that it will return only pageArea content nodes
            _.each(view.childViews, function (childView) {
                if (childView.model) {
                    var childModel = childView.model;
                    if (!className && childModel.isContainer) {
                        contentList._append(childModel);
                    } else if (childModel.className == className) {
                        contentList._append(childModel);
                    }
                }
                //Time to recurse

                if (childView._isPlaceHolderEl() && childView.model) {
                    //For hidden views that have never been initialized, we would want to return all contained nodes since we stitch
                    //hidden node together in first page.
                    contentList._concat(this.$nodeContent(childView.model, className, bPageArea));
                }
                else {
                    contentList._concat(this.$pageContent(childView, className, bPageArea));
                }

            }, this);
            return contentList;
        }

    });
})(_, $, xfalib);
(function(_, $, xfalib){

        xfalib.view.DataTableView = xfalib.view.ContainerView.extend({

        $elchildren : function(id) {
            return this.$el.children().children(id);
        },

        _getScreenReaderText: xfalib.view.FieldView.prototype._getScreenReaderText,

        _assignToolTip : xfalib.view.FieldView.prototype._assignToolTip

        });
})(_, $, xfalib);
(function(_, $, xfalib){
    var root = window;
    root.xfaViewRegistry = (function(){
        var _templateCache = new xfalib.view.util.HtmlTemplateCache();
        var _layoutManager = new xfalib.view.layout.LayoutManager();
        var xfaUtil = xfalib.ut.XfaUtil.prototype;

        var _viewTypeRegistry = {
            BaseView : xfalib.view.BaseView,
            FieldView : xfalib.view.FieldView,
            NumericFieldView : xfalib.view.NumericFieldView,
            ChoiceListFieldView : xfalib.view.ChoiceListFieldView,
            ObjectView : xfalib.view.ObjectView,
            SubformView : xfalib.view.SubformView,
            SubformSetView : xfalib.view.SubformSetView,
            PageView : xfalib.view.PageView,
            ContentAreaView : xfalib.view.ContentAreaView,
            RootSubformView : xfalib.view.RootSubformView,
            ContainerView : xfalib.view.ContainerView,
            ButtonFieldView : xfalib.view.ButtonFieldView,
            CheckButtonFieldView : xfalib.view.CheckButtonFieldView,
            TextFieldView : xfalib.view.TextFieldView,
            SignatureFieldView : xfalib.view.SignatureFieldView,
            ImageFieldView : xfalib.view.ImageFieldView,
            XfaDrawView : xfalib.view.XfaDrawView,
            DateTimeFieldView: xfalib.view.DateTimeFieldView,
            ExclGroupView: xfalib.view.ExclGroupView,
            DataTableView: xfalib.view.DataTableView
        };

        var _defaultDraw = {
            view : _viewTypeRegistry.XfaDrawView
        };

        var _defaultField = {
            view : _viewTypeRegistry.FieldView,
            widgetTemplate : null,
            viewInitConfig : {
                commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                commitProperty : "value",
                commitTarget : "rawValue"
            }
        };
        var _defaultContainer = {
            view : _viewTypeRegistry.ContainerView
        };
        var _defaultDataTable = {
            view : _viewTypeRegistry.DataTableView
        };

        var _nodeTypeRegistry = {
            //Containers
            "area" :    _defaultContainer,
            "contentarea" : {view : _viewTypeRegistry.ContentAreaView},
            "exclgroup" : {view : _viewTypeRegistry.ExclGroupView},
            "page" : {view : _viewTypeRegistry.PageView},
            "subform" : {view : _viewTypeRegistry.SubformView},
            "subformset" : {view : _viewTypeRegistry.SubformSetView},
            "rootsubform" : {view : _viewTypeRegistry.RootSubformView},

            //Fields
            "textfield" : {
                view : _viewTypeRegistry.TextFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "signaturefield" : {
                view : _viewTypeRegistry.SignatureFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "textareafield" : {
                view : _viewTypeRegistry.TextFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "numericfield" : {
                view : _viewTypeRegistry.NumericFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "imagefield" : {
                view : _viewTypeRegistry.ImageFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    commitProperty : "src",
                    commitTarget : "rawValue"
                }
            },
            "datefield" : {
                view : _viewTypeRegistry.DateTimeFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "timefield" : _defaultField,
            "datetimefield" : _defaultField,
            "passwordfield" : _defaultField,
            "buttonfield" : {
                view : _viewTypeRegistry.ButtonFieldView,
                viewInitConfig : {
                    commitEvent : null,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "submitfield" : _defaultDraw,
            "radiofield" : {
                view : _viewTypeRegistry.CheckButtonFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "checkboxfield" : {
                view : _viewTypeRegistry.CheckButtonFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "choicelist" : {
                view : _viewTypeRegistry.ChoiceListFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            }
        };


        return {
            viewTypeRegistry : _viewTypeRegistry,
            rootSubformView : null,
            nodeTypeRegistry : _nodeTypeRegistry,
            _userConfig : null,

            widgetConfig : function(){
                if(this._userConfig && this._userConfig["widgetConfig"]){
                    return this._userConfig["widgetConfig"];
                }
            },

            pagingConfig : function(){
                if(this._userConfig && this._userConfig["pagingConfig"]){
                    return this._userConfig["pagingConfig"];
                }
                var shrinkPageDisabledValue = false;
                if(this._userConfig && this._userConfig["behaviorConfig"]){
                    //TODO: Create a generic method somewhere in FormBridge?
                    var version = new xfalib.ut.Version(this._userConfig["behaviorConfig"]);
                    if(version.isPreviousOrSame(version.ES4))
                        shrinkPageDisabledValue = true;
                }

                return {
                    pagingDisabled : false,
                    shrinkPageDisabled : shrinkPageDisabledValue
                };
            },

            lookUpView : function(options){
                options = options || {};

                if(options.dataTable)
                    return _defaultDataTable;
                var nodeTypeView = this.nodeTypeRegistry[options.nodeType];
                if(nodeTypeView)
                    return nodeTypeView;

                if(options.field)
                    return _defaultField;
                else if(options.draw)
                    return _defaultDraw;
                else
                    return _defaultContainer;
            },

            createView : function(htmlDomNode, options){
                var $htmlDomNode = $(htmlDomNode);
                var nodeType = (xfaUtil.$data($htmlDomNode.get(0), xfalib.view.LayoutConst.XFA_MODEL) ||{})[xfalib.view.LayoutConst.NODE_TYPE];
                var isField = $htmlDomNode.hasClass("field");
                var isDraw = $htmlDomNode.hasClass("draw");
                var isDataTable = ($htmlDomNode.prop("tagName") == "TABLE");
                var isDataTableRow = ($htmlDomNode.prop("tagName") == "TR");
                var isDataTableCell = ($htmlDomNode.prop("tagName") == "TD" || $htmlDomNode.prop("tagName") == "TH" );
                var viewOptions = {
                    "nodeType" : nodeType,
                    "field" : isField,
                    "draw" : isDraw,
                    "dataTable" : isDataTable,
                    "dataTableRow" : isDataTableRow,
                    "dataTableCell" : isDataTableCell
                };
                var viewConfig = this.lookUpView(viewOptions);
                var initParam =  _.extend(
                    {el:htmlDomNode},
                    viewConfig["viewInitConfig"],
                    options
                );
                var viewInstance =  new viewConfig["view"](initParam);
                return viewInstance;
            },

            /**
             * Clears the template cache. The API is needed to clear the cache when
             * unloading one form and loading another form in Form Set.
             */
            clearTemplateCache: function () {
                _templateCache = new xfalib.view.util.HtmlTemplateCache();
            },

            /**
             * Clears the Layout Manager. The API is needed to unload the layout Manager
             * when unloading one form and loading another form in Form Set.
             */
            resetLayoutManager : function () {
              _layoutManager = new xfalib.view.layout.LayoutManager();
            },

            /**
             * The function is used to destroy the resources held by the object.
             * This function is called when the form is destroyed.
             */
            destroy: function () {
                _templateCache = undefined;
                _layoutManager = undefined;
            },

            templateCache : function(){
                return _templateCache;
            },

            layoutManager : function(){
                return _layoutManager;
            },


            /*
             * look ups the formWidth value in behaviourConfig; and if browser supports scaling, enforce that width by scaling the form
             */
            scaleForm: function () {
                var formWidth = this._userConfig["viewportWidth"];
                if (formWidth) {
                    var timeout = window.setTimeout(function () {     // wait for enough time to let layout complete
                        formWidth = parseInt(formWidth);
                        var pageMaxWidth = 0;
                        $(".page").each(function (i, obj) {
                            var tmpWidth = parseInt($(obj).width());
                            if (tmpWidth > pageMaxWidth)
                                pageMaxWidth = tmpWidth;
                        });
                        var width = pageMaxWidth,
                            height = parseInt($("body").height()),
                            scaleFactor = xfalib.ut.XfaUtil.prototype.formScaleFactor = formWidth / width,
                            transformValue = "scale(" + scaleFactor + ")",
                            marginHeight = height - scaleFactor * height,
                            marginWidth = width - scaleFactor * width,
                            scaleStyles = {
                                "-webkit-transform": transformValue, /* Saf3.1+, Chrome */
                                "-moz-transform": transformValue, /* FF3.5+ */
                                "-ms-transform": transformValue, /* IE9 */
                                "transform": transformValue,
                                "-webkit-transform-origin": "0 0",
                                "-moz-transform-origin": "0 0",
                                "-ms-transform-origin": "0 0",
                                "transform-origin": "0 0",
                                /* below two values are based on total heuristics. best combination to get thing working cross browser:
                                 *  In few browsers, after scaling there is blank space on bottom so margin-bottom is used with negative value.
                                 *  margin right is required for removing space on right in few browser, after scaling.
                                 *  And interestingly, formulae for both are different, not my mistake- total heuristics.
                                 *  IE still has space left in bottom&right in scaled down version but works good in scale up version.
                                 *  New, step would be to make these values per browser type. But common for now.
                                 * */
                                "margin-bottom": Math.min(0, -1 * marginHeight),
                                "margin-right": -1 * marginWidth
                            }
                        $("body").css(scaleStyles);
                        $(".page").css("margin", 0);
                        /*dispatch event so that toolbar and other widths can be re-computed.*/
                        $(window.formBridge).trigger("xfaFormScale");
                    }, 100);
                    xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(timeout);
                }
            },

            /*
             * Invalidates tab indexes for given page number. Note that page number starts with one.
             */
            invalidateTabIndex : function(pageNum){
                if(pageNum > -1 && this.rootSubformView && this.rootSubformView.childViews ){
                    var pageView = this.rootSubformView.childViews[pageNum -1];
                    if(pageView){
                        pageView.invalidateTabIndex();
                    }
                }
            }
        };
    })();

    root.xfaViewRegistry.initializeView = function(firstPageHtmlStr, restOfThePages){
        var viewStartTime = Date.now();
        var $formHtml = $(firstPageHtmlStr);
        var options = {};
        options.restOfThePages = restOfThePages;
        var pagingManager = new xfalib.view.PagingManager();
        xfalib.runtime.xfa.host.pagingManager = pagingManager;
        xfalib.runtime.xfa.$layout.pagingManager = pagingManager;
        window.xfaViewRegistry.rootSubformView = window.xfaViewRegistry.createView($formHtml, options);
        xfalib.runtime.xfa.host.on(xfalib.script.XfaModelEvent.FORM_MODEL_REFRESH,{
            handleEvent: function(evnt) {
                switch(evnt.name) {
                    case xfalib.script.XfaModelEvent.FORM_MODEL_REFRESH:
                        window.xfaViewRegistry.rootSubformView.syncFormNodeToHtml(true);
                        break;
                    default:
                    /* log an error message */
                }
            }
        });
        //TODO: move this to Logger
        formBridge.viewTime = Date.now()-viewStartTime;
        xfalib.runtime.xfa.Logger.debug("xfaView","################ total time to create view:"+formBridge.viewTime);
        return $formHtml;
    };

    root.xfaViewRegistry.initializeModel = function(xfaJson, xfaDataMergeDorm, xfalocaleset, xfarendercontext) {
        //read renderContext and other xfa specific node and push it
        xfalib.runtime.renderContext = xfarendercontext;

        if(xfalib.ut.XfaUtil.prototype.getOrElse(xfalib.runtime, "customPropertyMap.xmlOnClient", "0") === "1") {
            if(xfalib.runtime.renderContext.data) {
                formBridge.playDataXML({
                    xmlDocument : xfalib.runtime.renderContext.data
                });
            }
        }
        //read localeset as well
        xfaJson.localeSet = xfalocaleset;

        //Create Xfa Node
        xfalib.script.XfaModelRegistry.prototype.createModel(xfaJson);       //TODO: Handle window dependency

        if(xfalib.runtime.xfa.Logger.isLogEnabled("xfa", xfalib.ut.Logger.prototype.TRACE)){
            xfalib.runtime.xfa.Logger.trace("xfa","################ t0 xfadom:\n" + JSON.stringify(xfaJson));
        }

        var hasRestoreState = false;
        if (window.formBridge != undefined) {
            var localStorage = window.formBridge._getStorage();
            if (localStorage && localStorage.xfaDom) {
                xfaJson = JSON.parse(localStorage.xfaDom);
                if(xfaJson) {
                    hasRestoreState = true;
                    if(xfalib.runtime.xfa.Logger.isLogEnabled("xfa", xfalib.ut.Logger.prototype.TRACE)){
                        xfalib.runtime.xfa.Logger.trace("xfa","################ restore xfadom:\n" + JSON.stringify(xfaJson));
                    }
                    xfalib.runtime.xfa.host.playJson(xfaJson);
                }
            }
            var xmlStorage = window.formBridge._getXmlStorage();
            if(xmlStorage) {
                xfalib.runtime.xfa.Logger.trace("xfa","################ restore xml:\n" + xmlStorage);
                try {
                    xfalib.runtime.xfa.host.playDataXml(xmlStorage);
                } catch(exception) {
                    xfalib.runtime.xfa.Logger.error("xfa", "restoring xml failed ")
                    if(_.isFunction(formBridge.xmlStorage.error)) {
                        var resObj = formBridge._getResultObject();
                        resObj.addMessage(2, exception, null);
                        formBridge.xmlStorage.error.apply(formBridge.xmlStorage.context, [resObj])
                        //to ensure that success handler is not called after form render from FormBridge._xfaInitialized
                        formBridge.xmlStorage.success = null;
                    }
                }
            }
        }
        if( xfalib.ut.XfaUtil.prototype.getOrElse(xfalib.runtime, "customPropertyMap.xmlOnClient", "0") !== "1") {
            if(!hasRestoreState && xfaDataMergeDorm){
                if(xfalib.runtime.xfa.Logger.isLogEnabled("xfa", xfalib.ut.Logger.prototype.TRACE)){
                    xfalib.runtime.xfa.Logger.trace("xfa","################ restore xfadom:\n" + JSON.stringify(xfaDataMergeDorm));
                }
                xfalib.runtime.xfa.host.playJson(xfaDataMergeDorm);
            }
        }
        if( xfalib.ut.XfaUtil.prototype.getOrElse(xfalib.runtime, "customPropertyMap.destroyOnExit", "0") === "1") {
            $(window).on("beforeunload.xfa", function () {
                formBridge.destroyForm(true);
            });
        }
    };

    root.xfaViewRegistry.initializeFormOnDomReady = function() {
        $(function($){
            try {
                var initStart = Date.now();
                //initialize Acrobat specific scripts
                new xfalib.acrobat.Acrobat();
                if(xfalib.runtime.xfa) {
                    xfalib.runtime.xfa.form._initialize(true);
                    $(window).trigger("XfaInitialized");
                }
                formBridge.modelInitTime = Date.now()-initStart;
                xfalib.view.FieldView.prototype.currentFocus = null;
                $(window).on("mousedown.xfa", function() {
                    formBridge.clickedOnWindow = true;
                });
            } catch(e) {
                xfalib.runtime.xfa.Logger.error("xfa","error in form._initialize");
                if(e.stack){
                    xfalib.runtime.xfa.Logger.error("xfa", e.stack);
                }
            }
        });
    };

    //TODO: Put below call at proper place
    window._initializeXfaLoading = function (xfaJson, xfaDataMergeDorm, xfalocaleset, xfarendercontext, fileAttachmentMap) {
        window.formBridge._postExternalMessage({name : "_formdomstart"});
        var xfaModelLoadStart = Date.now();
        var xfaViewRegistry = window.xfaViewRegistry;

        //read internal css and attach it to head
        //excuse m
        if($('#formLoadingDiv').data('internalcss')) {
            var internalcss = $('#formLoadingDiv').data('internalcss'),
                styleTag = '<style id="mfstyle" type="text/css">'+internalcss+'</style>';
            //insert internal css before the first style element.
            if($('head>style:first').length > 0)
                $('head>style:first').before(styleTag);
            else if($('head').length > 0)
                $('head').append(styleTag);
            else if($('body').length > 0)
                $('body').prepend(styleTag);
            else if($('html').length > 0)
                $('html').prepend(styleTag);
            else
                $('#formLoadingDiv').prepend(styleTag);
        }

        xfaViewRegistry.initializeModel(xfaJson, xfaDataMergeDorm, xfalocaleset, xfarendercontext);

        window.formBridge._postExternalMessage({name : "_layoutstart"});
        xfaViewRegistry._userConfig = window.formBridge.userConfig;
        //TODO: move this to Logger
        formBridge.modelTime = Date.now()-xfaModelLoadStart;
        xfalib.runtime.xfa.Logger.debug("xfaView","################ total time to load xfa model:"+ formBridge.modelTime);

        xfalib.runtime.xfa.form.mbInitialized = false;

        var xfahtmldom =  $('#formLoadingDiv').data('xfahtmldom');
        var xfaresthtmldom = $('#formLoadingDiv').data('xfaresthtmldom');
        var xfahiddenobjdom = $('#formLoadingDiv').data('xfahiddenobjdom');

        xfalib.runtime.xfa.Logger.trace("xfaView","################ xfahtmldom:\n" + xfahtmldom);
        xfalib.runtime.xfa.Logger.trace("xfaView","################ xfaresthtmldom:\n" + xfaresthtmldom);
        xfalib.runtime.xfa.Logger.trace("xfaView","################ xfahiddenobjdom:\n <a>" + xfahiddenobjdom + "</a>");

        xfaViewRegistry.templateCache().setHiddenObjPages(xfahiddenobjdom); //cache the pages with hidden object layout
        $('#formLoadingDiv').replaceWith(xfaViewRegistry.initializeView( xfahtmldom, xfaresthtmldom));

        xfalib.runtime.xfa.Logger.debug("xfaView","################ total time to load xfa model + view:"+(Date.now()-xfaModelLoadStart));
        window.formBridge._postExternalMessage({name : "_layoutend"});

        xfaViewRegistry.initializeFormOnDomReady();

        xfalib.runtime.xfa.form.mbInitialized = true;

        // Restore attachments
        // We are setting this which is passed by file attachment plugin to  the fileUpload widget
        // as options.value and then widget creation takes place
        if(xfalib.runtime) {
            xfalib.runtime.fileAttachment = fileAttachmentMap;
        }

    };

})(_, $, xfalib);
/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
(function ($) {

    function highlightFields() {
        $(".widget:not(.buttonfieldwidget,.submitfieldwidget)")
            .toggleClass("widgetBackGroundColorHighlight", xfalib.globals.highlight);
        $(".widget[data-mandatory='true'],.exclgroup[data-mandatory='true']")
            .toggleClass("widgetMandatoryBorder", xfalib.globals.highlight);
    }

    function _getToolbarWidth() {
        var _tbwidth = document.body.clientWidth;
        if (window.formBridge && window.formBridge.userConfig["viewportWidth"]) {
            _tbwidth = window.formBridge.userConfig["viewportWidth"];
        }
        $(".page").each(function (i, obj) {
            var extent = {};
            var tmpWidth = parseInt($(this).width());
            if (tmpWidth > _tbwidth)
                _tbwidth = tmpWidth;
        });
        return _tbwidth - 2;
    }

    function _setToolbarWidth() {
        var extent = {};
        extent["width"] = _getToolbarWidth();
        $(".toolbarheader").css(extent);
        $(".pagingfooter").css(extent);
        $(".toolbarheader").css("left", "0px");
        $(".toolbarheader").css("right", "0px");
    }

    //show toolbar button based on logger.
    window.formBridge.connect(
        function () {
            $("#loadingPage").hide();
            if (xfalib.runtime.xfa.Logger.isServerLoggingEnabled()) {
                $("#toolbarloggerbtn").css({display: "inline-block"});
                //register click handler to send logs
                $("#toolbarloggerbtn").click(function () {
                    xfalib.runtime.xfa.Logger.serverHandler();
                });
            }
        }
    );

    $(window).one('xfaFirstPgLayoutComplete', function() {
        $("#loadingPage").hide();
        $(".loadingBody").removeClass("loadingBody");
    });

    //register when document is ready
    $(function ($) {

        var toolBarInit = function () {
            _setToolbarWidth();
            highlightFields();

            $(window).on('resize', _setToolbarWidth); // Bug#3670394 : changed $('body') to $(window)
            $(formBridge).on('xfaFormScale', _setToolbarWidth); // rescale the toolbar
            try {
                window.parent.addEventListener('orientationchange', function () {
                    window.xfaViewRegistry.scaleForm();
                });
            }
            catch (e) {
                xfalib.runtime.xfa.Logger.error("xfa", "could not register orientationchange listener");
            }

            $(formBridge).on("xfaNextPageRendered xfaLayoutComplete", highlightFields);

            $('#toolbarhighlight').on('click', function () {
                xfalib.globals.highlight = !xfalib.globals.highlight;
                highlightFields();
            });
        };
        //Bug#3605558: iPad doesn't give the width values instantaneously, hence putting a time out since we need
        // width of the pages rendered.
        setTimeout(function () {
            if (!xfalib.runtime.xfa)  //Bug#3670373: In IE, doc.ready is called too early for some forms, so xfalib.runtime.xfa is undefined
                $(window).one('xfaFirstPgLayoutComplete', toolBarInit);
            else
                toolBarInit();
        }, 100);


    });
})($);


/* ========================================================================
 * Bootstrap: modal.js v3.4.1
 * https://getbootstrap.com/docs/3.4/javascript/#modals
 * ========================================================================
 * Copyright 2011-2019 Twitter, Inc.
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 * ======================================================================== */


(function ($) {
    'use strict';

    // MODAL CLASS DEFINITION
    // ======================

    var Modal = function (element, options) {
        this.options = options
        this.$body = $(document.body)
        this.$element = $(element)
        this.$dialog = this.$element.find('.modal-dialog')
        this.$backdrop = null
        this.isShown = null
        this.originalBodyPad = null
        this.scrollbarWidth = 0
        this.ignoreBackdropClick = false
        this.fixedContent = '.navbar-fixed-top, .navbar-fixed-bottom'

        if (this.options.remote) {
            this.$element
                .find('.modal-content')
                .load(this.options.remote, $.proxy(function () {
                    this.$element.trigger('loaded.bs.modal')
                }, this))
        }
    }

    Modal.VERSION = '3.4.1'

    Modal.TRANSITION_DURATION = 300
    Modal.BACKDROP_TRANSITION_DURATION = 150

    Modal.DEFAULTS = {
        backdrop: true,
        keyboard: true,
        show: true
    }

    Modal.prototype.toggle = function (_relatedTarget) {
        return this.isShown ? this.hide() : this.show(_relatedTarget)
    }

    Modal.prototype.show = function (_relatedTarget) {
        var that = this
        var e = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })

        this.$element.trigger(e)

        if (this.isShown || e.isDefaultPrevented()) return

        this.isShown = true

        this.checkScrollbar()
        this.setScrollbar()
        this.$body.addClass('modal-open')

        this.escape()
        this.resize()

        this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))

        this.$dialog.on('mousedown.dismiss.bs.modal', function () {
            that.$element.one('mouseup.dismiss.bs.modal', function (e) {
                if ($(e.target).is(that.$element)) that.ignoreBackdropClick = true
            })
        })

        this.backdrop(function () {
            var transition = $.support.transition && that.$element.hasClass('fade')

            if (!that.$element.parent().length) {
                that.$element.appendTo(that.$body) // don't move modals dom position
            }

            that.$element
                .show()
                .scrollTop(0)

            that.adjustDialog()

            if (transition) {
                that.$element[0].offsetWidth // force reflow
            }

            that.$element.addClass('in')

            that.enforceFocus()

            var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })

            transition ?
                that.$dialog // wait for modal to slide in
                    .one('bsTransitionEnd', function () {
                        that.$element.trigger('focus').trigger(e)
                    })
                    .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
                that.$element.trigger('focus').trigger(e)
        })
    }

    Modal.prototype.hide = function (e) {
        if (e) e.preventDefault()

        e = $.Event('hide.bs.modal')

        this.$element.trigger(e)

        if (!this.isShown || e.isDefaultPrevented()) return

        this.isShown = false

        this.escape()
        this.resize()

        $(document).off('focusin.bs.modal')

        this.$element
            .removeClass('in')
            .off('click.dismiss.bs.modal')
            .off('mouseup.dismiss.bs.modal')

        this.$dialog.off('mousedown.dismiss.bs.modal')

        $.support.transition && this.$element.hasClass('fade') ?
            this.$element
                .one('bsTransitionEnd', $.proxy(this.hideModal, this))
                .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
            this.hideModal()
    }

    Modal.prototype.enforceFocus = function () {
        $(document)
            .off('focusin.bs.modal') // guard against infinite focus loop
            .on('focusin.bs.modal', $.proxy(function (e) {
                if (document !== e.target &&
                    this.$element[0] !== e.target &&
                    !this.$element.has(e.target).length) {
                    this.$element.trigger('focus')
                }
            }, this))
    }

    Modal.prototype.escape = function () {
        if (this.isShown && this.options.keyboard) {
            this.$element.on('keydown.dismiss.bs.modal', $.proxy(function (e) {
                e.which == 27 && this.hide()
            }, this))
        } else if (!this.isShown) {
            this.$element.off('keydown.dismiss.bs.modal')
        }
    }

    Modal.prototype.resize = function () {
        if (this.isShown) {
            $(window).on('resize.bs.modal', $.proxy(this.handleUpdate, this))
        } else {
            $(window).off('resize.bs.modal')
        }
    }

    Modal.prototype.hideModal = function () {
        var that = this
        this.$element.hide()
        this.backdrop(function () {
            that.$body.removeClass('modal-open')
            that.resetAdjustments()
            that.resetScrollbar()
            that.$element.trigger('hidden.bs.modal')
        })
    }

    Modal.prototype.removeBackdrop = function () {
        this.$backdrop && this.$backdrop.remove()
        this.$backdrop = null
    }

    Modal.prototype.backdrop = function (callback) {
        var that = this
        var animate = this.$element.hasClass('fade') ? 'fade' : ''

        if (this.isShown && this.options.backdrop) {
            var doAnimate = $.support.transition && animate

            this.$backdrop = $(document.createElement('div'))
                .addClass('modal-backdrop ' + animate)
                .appendTo(this.$body)

            this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
                if (this.ignoreBackdropClick) {
                    this.ignoreBackdropClick = false
                    return
                }
                if (e.target !== e.currentTarget) return
                this.options.backdrop == 'static'
                    ? this.$element[0].focus()
                    : this.hide()
            }, this))

            if (doAnimate) this.$backdrop[0].offsetWidth // force reflow

            this.$backdrop.addClass('in')

            if (!callback) return

            doAnimate ?
                this.$backdrop
                    .one('bsTransitionEnd', callback)
                    .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
                callback()

        } else if (!this.isShown && this.$backdrop) {
            this.$backdrop.removeClass('in')

            var callbackRemove = function () {
                that.removeBackdrop()
                callback && callback()
            }
            $.support.transition && this.$element.hasClass('fade') ?
                this.$backdrop
                    .one('bsTransitionEnd', callbackRemove)
                    .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
                callbackRemove()

        } else if (callback) {
            callback()
        }
    }

    // these following methods are used to handle overflowing modals

    Modal.prototype.handleUpdate = function () {
        this.adjustDialog()
    }

    Modal.prototype.adjustDialog = function () {
        var modalIsOverflowing = this.$element[0].scrollHeight > document.documentElement.clientHeight

        this.$element.css({
            paddingLeft: !this.bodyIsOverflowing && modalIsOverflowing ? this.scrollbarWidth : '',
            paddingRight: this.bodyIsOverflowing && !modalIsOverflowing ? this.scrollbarWidth : ''
        })
    }

    Modal.prototype.resetAdjustments = function () {
        this.$element.css({
            paddingLeft: '',
            paddingRight: ''
        })
    }

    Modal.prototype.checkScrollbar = function () {
        var fullWindowWidth = window.innerWidth
        if (!fullWindowWidth) { // workaround for missing window.innerWidth in IE8
            var documentElementRect = document.documentElement.getBoundingClientRect()
            fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left)
        }
        this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth
        this.scrollbarWidth = this.measureScrollbar()
    }

    Modal.prototype.setScrollbar = function () {
        var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)
        this.originalBodyPad = document.body.style.paddingRight || ''
        var scrollbarWidth = this.scrollbarWidth
        if (this.bodyIsOverflowing) {
            this.$body.css('padding-right', bodyPad + scrollbarWidth)
            $(this.fixedContent).each(function (index, element) {
                var actualPadding = element.style.paddingRight
                var calculatedPadding = $(element).css('padding-right')
                $(element)
                    .data('padding-right', actualPadding)
                    .css('padding-right', parseFloat(calculatedPadding) + scrollbarWidth + 'px')
            })
        }
    }

    Modal.prototype.resetScrollbar = function () {
        this.$body.css('padding-right', this.originalBodyPad)
        $(this.fixedContent).each(function (index, element) {
            var padding = $(element).data('padding-right')
            $(element).removeData('padding-right')
            element.style.paddingRight = padding ? padding : ''
        })
    }

    Modal.prototype.measureScrollbar = function () { // thx walsh
        var scrollDiv = document.createElement('div')
        scrollDiv.className = 'modal-scrollbar-measure'
        this.$body.append(scrollDiv)
        var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
        this.$body[0].removeChild(scrollDiv)
        return scrollbarWidth
    }


    // MODAL PLUGIN DEFINITION
    // =======================

    function Plugin(option, _relatedTarget) {
        return this.each(function () {
            var $this = $(this)
            var data = $this.data('bs.modal')
            var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)

            if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
            if (typeof option == 'string') data[option](_relatedTarget)
            else if (options.show) data.show(_relatedTarget)
        })
    }

    var old = $.fn.modal

    $.fn.modal = Plugin
    $.fn.modal.Constructor = Modal


    // MODAL NO CONFLICT
    // =================

    $.fn.modal.noConflict = function () {
        $.fn.modal = old
        return this
    }


    // MODAL DATA-API
    // ==============

    $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
        var $this = $(this)
        var href = $this.attr('href')
        var target = $this.attr('data-target') ||
            (href && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7

        var $target = $(document).find(target)
        var option = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())

        if ($this.is('a')) e.preventDefault()

        $target.one('show.bs.modal', function (showEvent) {
            if (showEvent.isDefaultPrevented()) return // only register focus restorer if modal will actually get shown
            $target.one('hidden.bs.modal', function () {
                $this.is(':visible') && $this.trigger('focus')
            })
        })
        Plugin.call($target, option, this)
    })

})($);

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/


$(function ($) {
    // $doc.ready for jquery 1.8 causing issues for IE so
    // doing widget initialization on connect
 window.formBridge.connect(function () {
     var method = {
         init: function () {
             var $plugFileWidgetDom = $('[data-filewidget="true"]'),
                 options,
                 $fileWidget,
                 $inputWidget,
                 $buttonWidget,
                 $listWidget,
                 widgetName,
                 multiSelect = true,
                 optionsToWidget;
                 options = $plugFileWidgetDom.data("options") || {};
                 options.buttonText = options.buttonText || "Attach";
                 options.accept = options.accept || "audio/*, video/*, image/*, text/*, application/pdf";
                 $fileWidget = $("<div></div>").addClass("guideFieldWidget").addClass("fileUpload").attr("style","")
                                               .attr("title", xfalib.locale.Strings["Attach"]);

                 $inputWidget = $("<input/>").attr("id", "fileUpload_widget").attr("name", "fileUpload")
                     .attr("type","file")
                     .attr("style", "")
                     .attr("accept",options.accept)
                     .attr("tabindex", "-1")
                     .attr("capture","");

                 $buttonWidget = $("<button></button>").addClass("button-default").addClass("button-medium")
                     .addClass("guide-fu-attach-button")
                     .attr("type", "file")
                     .html(options.buttonText);

                 $listWidget= $('<ul></ul>').addClass("guide-fu-fileItemList");
                 $fileWidget.append($inputWidget).append($buttonWidget).append($listWidget);
                 $fileWidget.appendTo($plugFileWidgetDom);
                 widgetName = options.widgetName || "fileUpload";
                 // multiSelect is expected to be boolean by widget
                 // And the profile node passes it as string
                 // and widget.jsp passes the same as boolean
                 //  options.multiSelect can be "true" ,  "false"
                 // or can be true ,  false
                 // or it can be undefined (when initializing  multiSelect  to true defines default behaviour )
                 if(_.isBoolean(options.multiSelect)) {
                     multiSelect = options.multiSelect;
                 } else if (_.isString(options.multiSelect)) {
                     multiSelect = options.multiSelect.toLowerCase() === 'true';
                 }
                 optionsToWidget =   {
                     buttonText  : options.buttonText || "Attach",
                     multiSelect :  multiSelect,
                     fileSizeLimit : options.fileSizeLimit || "2",
                     buttonClass : options.buttonClass || "button.guide-fu-attach-button",
                     fileItemListClass : options.fileItemListClass|| "ul.guide-fu-fileItemList",
                     iframeContainer: options.iframeContainer || "body#formBody",
                     showComment :  options.showComment || false,
                     _uuidGenerator: function () { return formBridge._getUUID.apply(this); },
                     value: options.value || xfalib.runtime.fileAttachment ,
                     _filePath: options._filePath || "/tmp/fd/xfaforns",
                     widgetName: "fileUpload",
                     _getUrl: options._getUrl || formBridge._getUrl(""),
                     disablePreview: options.disablePreview || false,
                     uploaderPluginName: "adobeFileUploader"



                 };
                 var widget = $fileWidget[widgetName](optionsToWidget);
                 xfalib.runtime.fileUploadWidget = widget.data(widgetName) || widget.data("xfaWidget-" + widgetName);
             }
     };
     method.init();
 });
});



/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function ($) {
    function handleScroll(event) {
        var pagingManager = window.formBridge ? window.formBridge.pagingManager() : null;
        var scrollTop = $(window).scrollTop();
        var winHeight = window.innerHeight ? window.innerHeight : $(window).height();
        var winBtmPos = scrollTop + winHeight;
        var $bodyEl = $("#formBody");
        /*We also need to take bodyScaleFactor into account in order to compare it with window height.*/
        var bodyBottom = $bodyEl.height() * xfalib.ut.XfaUtil.prototype.formScaleFactor + $bodyEl.offset().top;
        if (bodyBottom < winBtmPos + 50) {
            if (pagingManager && pagingManager.hasMorePages()) {
                $('#loadingpage').children(":not(a.pageloadnow)").css("visibility", "visible");
                xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(setTimeout(renderNextPage, 5)); //workaround for IPAD to show intermediate load icon
            }
        }
    }

    function handleFooterLogic() {
        var pagingManager = window.formBridge ? window.formBridge.pagingManager() : null;
        if (pagingManager == null) return;
        if (!pagingManager.hasMorePages()) {
            $('#loadingpage').css({display: "none"});
            $(window).off("scroll.xfaview");
            $('#nomorepages').css({display: "inline-block"});
        } else if (pagingManager.hasMorePages()) {
            $('#loadingpage').children(":not(a.pageloadnow)").css({visibility: "hidden"});
        }
    }

    function renderNextPage(initialLoad) {
        var pagingManager = window.formBridge ? window.formBridge.pagingManager() : null;
        if (!initialLoad && pagingManager) {
            pagingManager.renderNextPage();
        }
        handleFooterLogic();
        $(formBridge).trigger("xfaNextPageRendered");
    }

    window.renderNextPage = renderNextPage;
    window.handleFooterLogic = handleFooterLogic;
    window.handleScroll = handleScroll;
})($);


/**
 ADOBE CONFIDENTIAL

 Copyright 2014 Adobe Systems Incorporated
 All Rights Reserved.

 NOTICE:  All information contained herein is, and remains
 the property of Adobe Systems Incorporated and its suppliers,
 if any.  The intellectual and technical concepts contained
 herein are proprietary to Adobe Systems Incorporated and its
 suppliers and may be covered by U.S. and Foreign Patents,
 patents in process, and are protected by trade secret or copyright law.
 Dissemination of this information or reproduction of this material
 is strictly forbidden unless prior written permission is obtained
 from Adobe Systems Incorporated.
 */

(function ($) {
    window.FD = window.FD || {};
    FD.FP     = FD.FP || {};
    FD.FP.MF = FD.FP.MF || {};
    FD.FP.MF = {
        saveMFDraft : function(){
            var draftID = window.formBridge.customContextProperty("mfDraftId"),
                fileList = "",
                formPath = window.xfalib.runtime.renderContext.contentRoot.substring(6) + "/" +window.xfalib.runtime.renderContext.template,
                formName = window.xfalib.runtime.renderContext.template,
                formData =  null,
                urlForDraft = window.formBridge._getUrl(formPath) + "/jcr:content.fp.draft.json?func=saveDraft",
                profile = xfalib.runtime.customPropertyMap.profile,
                submitUrl = xfalib.runtime.customPropertyMap.submitUrl,
                instanceId = window.formBridge.customContextProperty("instanceId");

            var fileUploadPath = window.formBridge._getUrl(formPath) + "/jcr:content.fp.attach.jsp/" + draftID,
                showDraftStatus = function(message,id){
                                      $("#"+id).text(message).show().fadeOut(1600,"linear");
                                  };

            var obj = {
                "success":function(result){
                    window.formBridge.trigger(
                        "saveStarted",
                        window.xfalib.script.XfaModelEvent.createEvent ("saveStarted")
                    );
                    formData = result.data;
                    var data = {
                        'formName'  : formName,
                        'formPath'  : formPath,
                        'formData'  : formData,
                        'draftID'   : draftID,
                        'formType'  : "mf",
                        '_charset_' : "UTF-8",
                        'profile'   : profile,
                        'submitUrl' : submitUrl,
                        'fileList'  : fileList
                    },
                    allowedMetadata = [];

                    if(instanceId){
                        data["instanceId"] = instanceId;
                    }
                    for(key in data){
                        if(key !== 'formData') {
                            allowedMetadata.push(key);
                        }
                    }
                    data["fpAllowedMetadata"] = allowedMetadata.toString();
                    $.ajax({
                        type:"POST",
                        url: urlForDraft,
                        async: true,
                        cache: false,
                        data: data,
                        success: function (result) {
							if(result && result.draftID){
								window.formBridge.trigger(
									"saveCompleted",
									window.xfalib.script.XfaModelEvent.createEvent ("saveCompleted")
								);
								showDraftStatus(xfalib.locale.Strings.SavedSuccessfully, "fpDraftStatus");
								window.formBridge.customContextProperty("mfDraftId",result.draftID);
							} else {
							    showDraftStatus(xfalib.locale.Strings.UnableToSave,"fpDraftStatus");
							}
                        },
                        error : function (result) {
                            showDraftStatus(xfalib.locale.Strings.UnableToSave,"fpDraftStatus");
                        }
                    });
                },
                "error":function(result){
                    showDraftStatus(xfalib.locale.Strings.UnableToSave,"fpDraftStatus");
                }
            };
            var fileUploadObj = {
                "success":function(result){
                    $.each(result, function(index, res) {
                        fileList += res.path + "\n";
                    });
                    //to remove last '\n' from list
                    fileList = fileList.replace(/\n$/, "");
                    window.formBridge.getDataXML(obj);
                },
                "error":function(result){

                },
                "fileUploadPath":fileUploadPath
            };
            window.formBridge.getFileAttachmentsInfo(fileUploadObj);
        },

        _saveMFDraftWrapper: function () {
            if (typeof window.formBridge.customContextProperty("mfDraftId") === "undefined" || window.formBridge.customContextProperty("mfDraftId") == null) {
                $.ajax({
                    method: "GET",
                    url: Granite.HTTP.externalize("/content/forms/portal/draftandsubmission.fp.draft.json?func=getUid"),
                    cache : false,
                    dataType: "json"
                }).done(function (response) {
                    var draftID = response.id;
                    window.formBridge.customContextProperty("mfDraftId", draftID + "_mf");
                    FD.FP.MF.saveMFDraft();
                }).fail(function (errorObj) {
                    $("#fpDraftStatus").text(xfalib.locale.Strings.UnableToSave).show().fadeOut(1600,"linear");
                    return 0;
                });
            } else {
                FD.FP.MF.saveMFDraft();
            }
        }
    };

    $(document).ready(function(){
        $("#toolbarsavebtn").click(function(){
            window.FD.FP.MF._saveMFDraftWrapper();
        })
    });
})(jQuery);
/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 * Copyright 2023 Adobe
 * All Rights Reserved.
 *
 * NOTICE: All information contained herein is, and remains
 * the property of Adobe and its suppliers, if any. The intellectual
 * and technical concepts contained herein are proprietary to Adobe
 * and its suppliers and are protected by all applicable intellectual
 * property laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe.
 **************************************************************************/

(function () {
	window.FD = window.FD || {}
	var toggles;

	var httpEval = function (url) {
		var response = $.ajax({
			url: url,
			type: "get",
			async: false,
			dataType: "json"
		});
		if(response.status!=200){
           return;
        }
		var text = response.body ? response.body : response.responseText;
		return JSON.parse(text);
	};


	FD.isToggleEnabled = function (toggleName) {
		var contextRoot = (typeof formBridge !== 'undefined' && formBridge._getContextRoot()) ? formBridge._getContextRoot() :
			(typeof guideBridge !== 'undefined' && guideBridge._getContextRoot()) ? guideBridge._getContextRoot() : "";
		toggles = toggles || httpEval(contextRoot + "/etc.clientlibs/toggles.json");
		var retVal = false;
		if (toggles && toggles.enabled instanceof Array) {
			retVal = toggles.enabled.indexOf(toggleName) > -1
		}
		return retVal;
	}
})();


/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
(function($){
    window.formBridge.connect(
        function(){
            var titleResult = window.formBridge.getFieldProperties("xfa.form..desc.title","value");
            if(titleResult && !titleResult.errors && titleResult.data && titleResult.data[0]){
                $(document).attr('title', titleResult.data[0]);
            }
        }
    );
})($);


/*
 * ADOBE CONFIDENTIAL
 *
 * Copyright 2016 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 */

window.jQuery.noConflict(true);
if (!window.jQuery) {
    window.jQuery = window.xfalib.jQuery;
}
if (!window.$) {
    window.$ = window.xfalib.$;
}

window._.noConflict();
if (!window._) {
    window._ = window.xfalib._;
}
", + "base64Body" : "/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */
!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}S.fn=S.prototype={jquery:f,constructor:S,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(n){return this.pushStack(S.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(S.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},S.extend=S.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(S.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||S.isPlainObject(n)?n:{},i=!1,a[t]=S.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},S.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){b(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(p(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(p(Object(e))?S.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(p(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:y}),"function"==typeof Symbol&&(S.fn[Symbol.iterator]=t[Symbol.iterator]),S.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var d=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,S="sizzle"+1*new Date,p=n.document,k=0,r=0,m=ue(),x=ue(),A=ue(),N=ue(),j=function(e,t){return e===t&&(l=!0),0},D={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",F=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",B=new RegExp(M+"+","g"),$=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="<a id='"+S+"'></a><select id='"+S+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!=C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&D.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(j),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(B," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[k,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[k,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[S]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace($,"$1"));return s[S]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[k,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[S]||(e[S]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===k&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[S]&&(v=Ce(v)),y&&!y[S]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[S]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace($,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace($," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=A[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[S]?i.push(a):o.push(a);(a=A(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=k+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t==C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument==C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(k=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(k=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=S.split("").sort(j).join("")===S,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);S.find=d,S.expr=d.selectors,S.expr[":"]=S.expr.pseudos,S.uniqueSort=S.unique=d.uniqueSort,S.text=d.getText,S.isXMLDoc=d.isXML,S.contains=d.contains,S.escapeSelector=d.escape;var h=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&S(e).is(n))break;r.push(e)}return r},T=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},k=S.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1<i.call(n,e)!==r}):S.filter(n,e,r)}S.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?S.find.matchesSelector(r,e)?[r]:[]:S.find.matches(e,S.grep(t,function(e){return 1===e.nodeType}))},S.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(S(e).filter(function(){for(t=0;t<r;t++)if(S.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)S.find(e,i[t],n);return 1<r?S.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&k.test(e)?S(e):e||[],!1).length}});var D,q=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(S.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&S(e);if(!k.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&S.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?S.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(S(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(S.uniqueSort(S.merge(this.get(),S(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),S.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return h(e,"parentNode")},parentsUntil:function(e,t,n){return h(e,"parentNode",n)},next:function(e){return O(e,"nextSibling")},prev:function(e){return O(e,"previousSibling")},nextAll:function(e){return h(e,"nextSibling")},prevAll:function(e){return h(e,"previousSibling")},nextUntil:function(e,t,n){return h(e,"nextSibling",n)},prevUntil:function(e,t,n){return h(e,"previousSibling",n)},siblings:function(e){return T((e.parentNode||{}).firstChild,e)},children:function(e){return T(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(A(e,"template")&&(e=e.content||e),S.merge([],e.childNodes))}},function(r,i){S.fn[r]=function(e,t){var n=S.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=S.filter(t,n)),1<this.length&&(H[r]||S.uniqueSort(n),L.test(r)&&n.reverse()),this.pushStack(n)}});var P=/[^\x20\t\r\n\f]+/g;function R(e){return e}function M(e){throw e}function I(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}S.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},S.each(e.match(P)||[],function(e,t){n[t]=!0}),n):S.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){S.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return S.each(arguments,function(e,t){var n;while(-1<(n=S.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<S.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},S.extend({Deferred:function(e){var o=[["notify","progress",S.Callbacks("memory"),S.Callbacks("memory"),2],["resolve","done",S.Callbacks("once memory"),S.Callbacks("once memory"),0,"resolved"],["reject","fail",S.Callbacks("once memory"),S.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return S.Deferred(function(r){S.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,R,s),l(u,o,M,s)):(u++,t.call(e,l(u,o,R,s),l(u,o,M,s),l(u,o,R,o.notifyWith))):(a!==R&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){S.Deferred.exceptionHook&&S.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==M&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(S.Deferred.getStackHook&&(t.stackTrace=S.Deferred.getStackHook()),C.setTimeout(t))}}return S.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:R,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:R)),o[2][3].add(l(0,e,m(n)?n:M))}).promise()},promise:function(e){return null!=e?S.extend(e,a):a}},s={};return S.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=S.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(I(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)I(i[t],a(t),o.reject);return o.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;S.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&W.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},S.readyException=function(e){C.setTimeout(function(){throw e})};var F=S.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),S.ready()}S.fn.ready=function(e){return F.then(e)["catch"](function(e){S.readyException(e)}),this},S.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--S.readyWait:S.isReady)||(S.isReady=!0)!==e&&0<--S.readyWait||F.resolveWith(E,[S])}}),S.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(S.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var $=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)$(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(S(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},_=/^-ms-/,z=/-([a-z])/g;function U(e,t){return t.toUpperCase()}function X(e){return e.replace(_,"ms-").replace(z,U)}var V=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function G(){this.expando=S.expando+G.uid++}G.uid=1,G.prototype={cache:function(e){var t=e[this.expando];return t||(t={},V(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[X(t)]=n;else for(r in t)i[X(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][X(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(X):(t=X(t))in r?[t]:t.match(P)||[]).length;while(n--)delete r[t[n]]}(void 0===t||S.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!S.isEmptyObject(t)}};var Y=new G,Q=new G,J=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,K=/[A-Z]/g;function Z(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(K,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:J.test(i)?JSON.parse(i):i)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}S.extend({hasData:function(e){return Q.hasData(e)||Y.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return Y.access(e,t,n)},_removeData:function(e,t){Y.remove(e,t)}}),S.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=Q.get(o),1===o.nodeType&&!Y.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=X(r.slice(5)),Z(o,r,i[r]));Y.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){Q.set(this,n)}):$(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=Q.get(o,n))?t:void 0!==(t=Z(o,n))?t:void 0;this.each(function(){Q.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){Q.remove(this,e)})}}),S.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Y.get(e,t),n&&(!r||Array.isArray(n)?r=Y.access(e,t,S.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=S.queue(e,t),r=n.length,i=n.shift(),o=S._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){S.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Y.get(e,n)||Y.access(e,n,{empty:S.Callbacks("once memory").add(function(){Y.remove(e,[t+"queue",n])})})}}),S.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?S.queue(this[0],t):void 0===n?this:this.each(function(){var e=S.queue(this,t,n);S._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&S.dequeue(this,t)})},dequeue:function(e){return this.each(function(){S.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=S.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Y.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var ee=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,te=new RegExp("^(?:([+-])=|)("+ee+")([a-z%]*)$","i"),ne=["Top","Right","Bottom","Left"],re=E.documentElement,ie=function(e){return S.contains(e.ownerDocument,e)},oe={composed:!0};re.getRootNode&&(ie=function(e){return S.contains(e.ownerDocument,e)||e.getRootNode(oe)===e.ownerDocument});var ae=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&ie(e)&&"none"===S.css(e,"display")};function se(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return S.css(e,t,"")},u=s(),l=n&&n[3]||(S.cssNumber[t]?"":"px"),c=e.nodeType&&(S.cssNumber[t]||"px"!==l&&+u)&&te.exec(S.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)S.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,S.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ue={};function le(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Y.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&ae(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ue[s])||(o=a.body.appendChild(a.createElement(s)),u=S.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ue[s]=u)))):"none"!==n&&(l[c]="none",Y.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}S.fn.extend({show:function(){return le(this,!0)},hide:function(){return le(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){ae(this)?S(this).show():S(this).hide()})}});var ce,fe,pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="<option></option>",y.option=!!ce.lastChild;var ge={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Y.set(e[n],"globalEval",!t||Y.get(t[n],"globalEval"))}ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td,y.option||(ge.optgroup=ge.option=[1,"<select multiple='multiple'>","</select>"]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))S.merge(p,o.nodeType?[o]:o);else if(me.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+S.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;S.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<S.inArray(o,r))i&&i.push(o);else if(l=ie(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}var be=/^([^.]*)(?:\.(.+)|)/;function we(){return!0}function Te(){return!1}function Ce(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ee(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ee(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Te;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return S().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=S.guid++)),e.each(function(){S.event.add(this,t,i,r,n)})}function Se(e,i,o){o?(Y.set(e,i,!1),S.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Y.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(S.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Y.set(this,i,r),t=o(this,i),this[i](),r!==(n=Y.get(this,i))||t?Y.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n&&n.value}else r.length&&(Y.set(this,i,{value:S.event.trigger(S.extend(r[0],S.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Y.get(e,i)&&S.event.add(e,i,we)}S.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.get(t);if(V(t)){n.handler&&(n=(o=n).handler,i=o.selector),i&&S.find.matchesSelector(re,i),n.guid||(n.guid=S.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof S&&S.event.triggered!==e.type?S.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(P)||[""]).length;while(l--)d=g=(s=be.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=S.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=S.event.special[d]||{},c=S.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&S.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),S.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.hasData(e)&&Y.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(P)||[""]).length;while(l--)if(d=g=(s=be.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=S.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||S.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)S.event.remove(e,d+t[l],n,r,!0);S.isEmptyObject(u)&&Y.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=S.event.fix(e),l=(Y.get(this,"events")||Object.create(null))[u.type]||[],c=S.event.special[u.type]||{};for(s[0]=u,t=1;t<arguments.length;t++)s[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){a=S.event.handlers.call(this,u,l),t=0;while((i=a[t++])&&!u.isPropagationStopped()){u.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!u.isImmediatePropagationStopped())u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((S.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,s))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<S(i,this).index(l):S.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(S.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[S.expando]?e:new S.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Se(t,"click",we),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Se(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Y.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},S.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},S.Event=function(e,t){if(!(this instanceof S.Event))return new S.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?we:Te,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&S.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[S.expando]=!0},S.Event.prototype={constructor:S.Event,isDefaultPrevented:Te,isPropagationStopped:Te,isImmediatePropagationStopped:Te,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=we,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=we,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=we,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},S.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:!0},S.event.addProp),S.each({focus:"focusin",blur:"focusout"},function(e,t){S.event.special[e]={setup:function(){return Se(this,e,Ce),!1},trigger:function(){return Se(this,e),!0},_default:function(){return!0},delegateType:t}}),S.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){S.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||S.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),S.fn.extend({on:function(e,t,n,r){return Ee(this,e,t,n,r)},one:function(e,t,n,r){return Ee(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,S(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Te),this.each(function(){S.event.remove(this,e,n,t)})}});var ke=/<script|<style|<link/i,Ae=/checked\s*(?:[^=]|=\s*.checked.)/i,Ne=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)S.event.add(t,i,s[i][n]);Q.hasData(e)&&(o=Q.access(e),a=S.extend({},o),Q.set(t,a))}}function He(n,r,i,o){r=g(r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&Ae.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),He(t,r,i,o)});if(f&&(t=(e=xe(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=S.map(ve(e,"script"),De)).length;c<f;c++)u=e,c!==p&&(u=S.clone(u,!0,!0),s&&S.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,S.map(a,qe),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Y.access(u,"globalEval")&&S.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?S._evalUrl&&!u.noModule&&S._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):b(u.textContent.replace(Ne,""),u,l))}return n}function Oe(e,t,n){for(var r,i=t?S.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||S.cleanData(ve(r)),r.parentNode&&(n&&ie(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}S.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=ie(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||S.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Le(o[r],a[r]);else Le(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=S.event.special,o=0;void 0!==(n=e[o]);o++)if(V(n)){if(t=n[Y.expando]){if(t.events)for(r in t.events)i[r]?S.event.remove(n,r):S.removeEvent(n,r,t.handle);n[Y.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),S.fn.extend({detach:function(e){return Oe(this,e,!0)},remove:function(e){return Oe(this,e)},text:function(e){return $(this,function(e){return void 0===e?S.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return He(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||je(this,e).appendChild(e)})},prepend:function(){return He(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=je(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return He(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return He(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(S.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return S.clone(this,e,t)})},html:function(e){return $(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!ke.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=S.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(S.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return He(this,arguments,function(e){var t=this.parentNode;S.inArray(this,n)<0&&(S.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),S.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){S.fn[e]=function(e){for(var t,n=[],r=S(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),S(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var Pe=new RegExp("^("+ee+")(?!px)[a-z%]+$","i"),Re=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},Me=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Ie=new RegExp(ne.join("|"),"i");function We(e,t,n){var r,i,o,a,s=e.style;return(n=n||Re(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||ie(e)||(a=S.style(e,t)),!y.pixelBoxStyles()&&Pe.test(a)&&Ie.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function Fe(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",re.appendChild(u).appendChild(l);var e=C.getComputedStyle(l);n="1%"!==e.top,s=12===t(e.marginLeft),l.style.right="60%",o=36===t(e.right),r=36===t(e.width),l.style.position="absolute",i=12===t(l.offsetWidth/3),re.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s,u=E.createElement("div"),l=E.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===l.style.backgroundClip,S.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),s},scrollboxSize:function(){return e(),i},reliableTrDimensions:function(){var e,t,n,r;return null==a&&(e=E.createElement("table"),t=E.createElement("tr"),n=E.createElement("div"),e.style.cssText="position:absolute;left:-11111px;border-collapse:separate",t.style.cssText="border:1px solid",t.style.height="1px",n.style.height="9px",n.style.display="block",re.appendChild(e).appendChild(t).appendChild(n),r=C.getComputedStyle(t),a=parseInt(r.height,10)+parseInt(r.borderTopWidth,10)+parseInt(r.borderBottomWidth,10)===t.offsetHeight,re.removeChild(e)),a}}))}();var Be=["Webkit","Moz","ms"],$e=E.createElement("div").style,_e={};function ze(e){var t=S.cssProps[e]||_e[e];return t||(e in $e?e:_e[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Be.length;while(n--)if((e=Be[n]+t)in $e)return e}(e)||e)}var Ue=/^(none|table(?!-c[ea]).+)/,Xe=/^--/,Ve={position:"absolute",visibility:"hidden",display:"block"},Ge={letterSpacing:"0",fontWeight:"400"};function Ye(e,t,n){var r=te.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function Qe(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=S.css(e,n+ne[a],!0,i)),r?("content"===n&&(u-=S.css(e,"padding"+ne[a],!0,i)),"margin"!==n&&(u-=S.css(e,"border"+ne[a]+"Width",!0,i))):(u+=S.css(e,"padding"+ne[a],!0,i),"padding"!==n?u+=S.css(e,"border"+ne[a]+"Width",!0,i):s+=S.css(e,"border"+ne[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function Je(e,t,n){var r=Re(e),i=(!y.boxSizingReliable()||n)&&"border-box"===S.css(e,"boxSizing",!1,r),o=i,a=We(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(Pe.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||!y.reliableTrDimensions()&&A(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===S.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===S.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+Qe(e,t,n||(i?"border":"content"),o,r,a)+"px"}function Ke(e,t,n,r,i){return new Ke.prototype.init(e,t,n,r,i)}S.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=We(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=X(t),u=Xe.test(t),l=e.style;if(u||(t=ze(s)),a=S.cssHooks[t]||S.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=te.exec(n))&&i[1]&&(n=se(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(S.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=X(t);return Xe.test(t)||(t=ze(s)),(a=S.cssHooks[t]||S.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=We(e,t,r)),"normal"===i&&t in Ge&&(i=Ge[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),S.each(["height","width"],function(e,u){S.cssHooks[u]={get:function(e,t,n){if(t)return!Ue.test(S.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?Je(e,u,n):Me(e,Ve,function(){return Je(e,u,n)})},set:function(e,t,n){var r,i=Re(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===S.css(e,"boxSizing",!1,i),s=n?Qe(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-Qe(e,u,"border",!1,i)-.5)),s&&(r=te.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=S.css(e,u)),Ye(0,t,s)}}}),S.cssHooks.marginLeft=Fe(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(We(e,"marginLeft"))||e.getBoundingClientRect().left-Me(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),S.each({margin:"",padding:"",border:"Width"},function(i,o){S.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+ne[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(S.cssHooks[i+o].set=Ye)}),S.fn.extend({css:function(e,t){return $(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Re(e),i=t.length;a<i;a++)o[t[a]]=S.css(e,t[a],!1,r);return o}return void 0!==n?S.style(e,t,n):S.css(e,t)},e,t,1<arguments.length)}}),((S.Tween=Ke).prototype={constructor:Ke,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||S.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(S.cssNumber[n]?"":"px")},cur:function(){var e=Ke.propHooks[this.prop];return e&&e.get?e.get(this):Ke.propHooks._default.get(this)},run:function(e){var t,n=Ke.propHooks[this.prop];return this.options.duration?this.pos=t=S.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):Ke.propHooks._default.set(this),this}}).init.prototype=Ke.prototype,(Ke.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=S.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){S.fx.step[e.prop]?S.fx.step[e.prop](e):1!==e.elem.nodeType||!S.cssHooks[e.prop]&&null==e.elem.style[ze(e.prop)]?e.elem[e.prop]=e.now:S.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=Ke.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},S.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},S.fx=Ke.prototype.init,S.fx.step={};var Ze,et,tt,nt,rt=/^(?:toggle|show|hide)$/,it=/queueHooks$/;function ot(){et&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(ot):C.setTimeout(ot,S.fx.interval),S.fx.tick())}function at(){return C.setTimeout(function(){Ze=void 0}),Ze=Date.now()}function st(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ne[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ut(e,t,n){for(var r,i=(lt.tweeners[t]||[]).concat(lt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function lt(o,e,t){var n,a,r=0,i=lt.prefilters.length,s=S.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=Ze||at(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:S.extend({},e),opts:S.extend(!0,{specialEasing:{},easing:S.easing._default},t),originalProperties:e,originalOptions:t,startTime:Ze||at(),duration:t.duration,tweens:[],createTween:function(e,t){var n=S.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=X(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=S.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=lt.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(S._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return S.map(c,ut,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),S.fx.timer(S.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}S.Animation=S.extend(lt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return se(n.elem,e,te.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(P);for(var n,r=0,i=e.length;r<i;r++)n=e[r],lt.tweeners[n]=lt.tweeners[n]||[],lt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ae(e),v=Y.get(e,"fxshow");for(r in n.queue||(null==(a=S._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,S.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],rt.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||S.style(e,r)}if((u=!S.isEmptyObject(t))||!S.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Y.get(e,"display")),"none"===(c=S.css(e,"display"))&&(l?c=l:(le([e],!0),l=e.style.display||l,c=S.css(e,"display"),le([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===S.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Y.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&le([e],!0),p.done(function(){for(r in g||le([e]),Y.remove(e,"fxshow"),d)S.style(e,r,d[r])})),u=ut(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?lt.prefilters.unshift(e):lt.prefilters.push(e)}}),S.speed=function(e,t,n){var r=e&&"object"==typeof e?S.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return S.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in S.fx.speeds?r.duration=S.fx.speeds[r.duration]:r.duration=S.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&S.dequeue(this,r.queue)},r},S.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ae).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=S.isEmptyObject(t),o=S.speed(e,n,r),a=function(){var e=lt(this,S.extend({},t),o);(i||Y.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=S.timers,r=Y.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&it.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||S.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Y.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=S.timers,o=n?n.length:0;for(t.finish=!0,S.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),S.each(["toggle","show","hide"],function(e,r){var i=S.fn[r];S.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(st(r,!0),e,t,n)}}),S.each({slideDown:st("show"),slideUp:st("hide"),slideToggle:st("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){S.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),S.timers=[],S.fx.tick=function(){var e,t=0,n=S.timers;for(Ze=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||S.fx.stop(),Ze=void 0},S.fx.timer=function(e){S.timers.push(e),S.fx.start()},S.fx.interval=13,S.fx.start=function(){et||(et=!0,ot())},S.fx.stop=function(){et=null},S.fx.speeds={slow:600,fast:200,_default:400},S.fn.delay=function(r,e){return r=S.fx&&S.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},tt=E.createElement("input"),nt=E.createElement("select").appendChild(E.createElement("option")),tt.type="checkbox",y.checkOn=""!==tt.value,y.optSelected=nt.selected,(tt=E.createElement("input")).value="t",tt.type="radio",y.radioValue="t"===tt.value;var ct,ft=S.expr.attrHandle;S.fn.extend({attr:function(e,t){return $(this,S.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){S.removeAttr(this,e)})}}),S.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?S.prop(e,t,n):(1===o&&S.isXMLDoc(e)||(i=S.attrHooks[t.toLowerCase()]||(S.expr.match.bool.test(t)?ct:void 0)),void 0!==n?null===n?void S.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=S.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(P);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),ct={set:function(e,t,n){return!1===t?S.removeAttr(e,n):e.setAttribute(n,n),n}},S.each(S.expr.match.bool.source.match(/\w+/g),function(e,t){var a=ft[t]||S.find.attr;ft[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=ft[o],ft[o]=r,r=null!=a(e,t,n)?o:null,ft[o]=i),r}});var pt=/^(?:input|select|textarea|button)$/i,dt=/^(?:a|area)$/i;function ht(e){return(e.match(P)||[]).join(" ")}function gt(e){return e.getAttribute&&e.getAttribute("class")||""}function vt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(P)||[]}S.fn.extend({prop:function(e,t){return $(this,S.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[S.propFix[e]||e]})}}),S.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&S.isXMLDoc(e)||(t=S.propFix[t]||t,i=S.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=S.find.attr(e,"tabindex");return t?parseInt(t,10):pt.test(e.nodeName)||dt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(S.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),S.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){S.propFix[this.toLowerCase()]=this}),S.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).addClass(t.call(this,e,gt(this)))});if((e=vt(t)).length)while(n=this[u++])if(i=gt(n),r=1===n.nodeType&&" "+ht(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=ht(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).removeClass(t.call(this,e,gt(this)))});if(!arguments.length)return this.attr("class","");if((e=vt(t)).length)while(n=this[u++])if(i=gt(n),r=1===n.nodeType&&" "+ht(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=ht(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){S(this).toggleClass(i.call(this,e,gt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=S(this),r=vt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=gt(this))&&Y.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Y.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+ht(gt(n))+" ").indexOf(t))return!0;return!1}});var yt=/\r/g;S.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,S(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=S.map(t,function(e){return null==e?"":e+""})),(r=S.valHooks[this.type]||S.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=S.valHooks[t.type]||S.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(yt,""):null==e?"":e:void 0}}),S.extend({valHooks:{option:{get:function(e){var t=S.find.attr(e,"value");return null!=t?t:ht(S.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=S(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=S.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<S.inArray(S.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),S.each(["radio","checkbox"],function(){S.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<S.inArray(S(e).val(),t)}},y.checkOn||(S.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var mt=/^(?:focusinfocus|focusoutblur)$/,xt=function(e){e.stopPropagation()};S.extend(S.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!mt.test(d+S.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[S.expando]?e:new S.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:S.makeArray(t,[e]),c=S.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,mt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Y.get(o,"events")||Object.create(null))[e.type]&&Y.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&V(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!V(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),S.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,xt),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,xt),S.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=S.extend(new S.Event,n,{type:e,isSimulated:!0});S.event.trigger(r,null,t)}}),S.fn.extend({trigger:function(e,t){return this.each(function(){S.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return S.event.trigger(e,t,n,!0)}}),y.focusin||S.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){S.event.simulate(r,e.target,S.event.fix(e))};S.event.special[r]={setup:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r);t||e.addEventListener(n,i,!0),Y.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r)-1;t?Y.access(e,r,t):(e.removeEventListener(n,i,!0),Y.remove(e,r))}}});var bt=C.location,wt={guid:Date.now()},Tt=/\?/;S.parseXML=function(e){var t,n;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){}return n=t&&t.getElementsByTagName("parsererror")[0],t&&!n||S.error("Invalid XML: "+(n?S.map(n.childNodes,function(e){return e.textContent}).join("\n"):e)),t};var Ct=/\[\]$/,Et=/\r?\n/g,St=/^(?:submit|button|image|reset|file)$/i,kt=/^(?:input|select|textarea|keygen)/i;function At(n,e,r,i){var t;if(Array.isArray(e))S.each(e,function(e,t){r||Ct.test(n)?i(n,t):At(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)At(n+"["+t+"]",e[t],r,i)}S.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!S.isPlainObject(e))S.each(e,function(){i(this.name,this.value)});else for(n in e)At(n,e[n],t,i);return r.join("&")},S.fn.extend({serialize:function(){return S.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=S.prop(this,"elements");return e?S.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!S(this).is(":disabled")&&kt.test(this.nodeName)&&!St.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=S(this).val();return null==n?null:Array.isArray(n)?S.map(n,function(e){return{name:t.name,value:e.replace(Et,"\r\n")}}):{name:t.name,value:n.replace(Et,"\r\n")}}).get()}});var Nt=/%20/g,jt=/#.*$/,Dt=/([?&])_=[^&]*/,qt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Lt=/^(?:GET|HEAD)$/,Ht=/^\/\//,Ot={},Pt={},Rt="*/".concat("*"),Mt=E.createElement("a");function It(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(P)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function Wt(t,i,o,a){var s={},u=t===Pt;function l(e){var r;return s[e]=!0,S.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function Ft(e,t){var n,r,i=S.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&S.extend(!0,e,r),e}Mt.href=bt.href,S.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:bt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(bt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Rt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":S.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Ft(Ft(e,S.ajaxSettings),t):Ft(S.ajaxSettings,e)},ajaxPrefilter:It(Ot),ajaxTransport:It(Pt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=S.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?S(y):S.event,x=S.Deferred(),b=S.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=qt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||bt.href)+"").replace(Ht,bt.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(P)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Mt.protocol+"//"+Mt.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=S.param(v.data,v.traditional)),Wt(Ot,v,t,T),h)return T;for(i in(g=S.event&&v.global)&&0==S.active++&&S.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Lt.test(v.type),f=v.url.replace(jt,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Nt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(Tt.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Dt,"$1"),o=(Tt.test(f)?"&":"?")+"_="+wt.guid+++o),v.url=f+o),v.ifModified&&(S.lastModified[f]&&T.setRequestHeader("If-Modified-Since",S.lastModified[f]),S.etag[f]&&T.setRequestHeader("If-None-Match",S.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+Rt+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=Wt(Pt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),!i&&-1<S.inArray("script",v.dataTypes)&&S.inArray("json",v.dataTypes)<0&&(v.converters["text script"]=function(){}),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(S.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(S.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--S.active||S.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return S.get(e,t,n,"json")},getScript:function(e,t){return S.get(e,void 0,t,"script")}}),S.each(["get","post"],function(e,i){S[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),S.ajax(S.extend({url:e,type:i,dataType:r,data:t,success:n},S.isPlainObject(e)&&e))}}),S.ajaxPrefilter(function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")}),S._evalUrl=function(e,t,n){return S.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){S.globalEval(e,t,n)}})},S.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=S(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){S(this).wrapInner(n.call(this,e))}):this.each(function(){var e=S(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){S(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){S(this).replaceWith(this.childNodes)}),this}}),S.expr.pseudos.hidden=function(e){return!S.expr.pseudos.visible(e)},S.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},S.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var Bt={0:200,1223:204},$t=S.ajaxSettings.xhr();y.cors=!!$t&&"withCredentials"in $t,y.ajax=$t=!!$t,S.ajaxTransport(function(i){var o,a;if(y.cors||$t&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Bt[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),S.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),S.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return S.globalEval(e),e}}}),S.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),S.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=S("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=ht(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&S.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?S("<div>").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}});var Xt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;S.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||S.guid++,i},S.holdReady=function(e){e?S.readyWait++:S.ready(!0)},S.isArray=Array.isArray,S.parseJSON=JSON.parse,S.nodeName=A,S.isFunction=m,S.isWindow=x,S.camelCase=X,S.type=w,S.now=Date.now,S.isNumeric=function(e){var t=S.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},S.trim=function(e){return null==e?"":(e+"").replace(Xt,"")},"function"==typeof define&&define.amd&&define("jquery",[],function(){return S});var Vt=C.jQuery,Gt=C.$;return S.noConflict=function(e){return C.$===S&&(C.$=Gt),e&&C.jQuery===S&&(C.jQuery=Vt),S},"undefined"==typeof e&&(C.jQuery=C.$=S),S});
/*!
 * jQuery UI Widget 1.13.2
 * http://jqueryui.com
 *
 * Copyright jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 */

//>>label: Widget
//>>group: Core
//>>description: Provides a factory for creating stateful widgets with a common API.
//>>docs: http://api.jqueryui.com/jQuery.widget/
//>>demos: http://jqueryui.com/widget/

( function( factory ) {
    if ( typeof define === "function" && define.amd ) {

        // AMD. Register as an anonymous module.
        define( [ "jquery" ], factory );
    } else {

        // Browser globals
        factory( jQuery );
    }
}( function( $ ) {
    "use strict";

    $.ui = $.ui || {};

    var version = $.ui.version = "1.13.2";

    var widgetUuid = 0;
    var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
    var widgetSlice = Array.prototype.slice;

    $.cleanData = ( function( orig ) {
        return function( elems ) {
            var events, elem, i;
            for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {

                // Only trigger remove when necessary to save time
                events = $._data( elem, "events" );
                if ( events && events.remove ) {
                    $( elem ).triggerHandler( "remove" );
                }
            }
            orig( elems );
        };
    } )( $.cleanData );

    $.widget = function( name, base, prototype ) {
        var existingConstructor, constructor, basePrototype;

        // ProxiedPrototype allows the provided prototype to remain unmodified
        // so that it can be used as a mixin for multiple widgets (#8876)
        var proxiedPrototype = {};

        var namespace = name.split( "." )[ 0 ];
        name = name.split( "." )[ 1 ];
        var fullName = namespace + "-" + name;

        if ( !prototype ) {
            prototype = base;
            base = $.Widget;
        }

        if ( Array.isArray( prototype ) ) {
            prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
        }

        // Create selector for plugin
        $.expr.pseudos[ fullName.toLowerCase() ] = function( elem ) {
            return !!$.data( elem, fullName );
        };

        $[ namespace ] = $[ namespace ] || {};
        existingConstructor = $[ namespace ][ name ];
        constructor = $[ namespace ][ name ] = function( options, element ) {

            // Allow instantiation without "new" keyword
            if ( !this || !this._createWidget ) {
                return new constructor( options, element );
            }

            // Allow instantiation without initializing for simple inheritance
            // must use "new" keyword (the code above always passes args)
            if ( arguments.length ) {
                this._createWidget( options, element );
            }
        };

        // Extend with the existing constructor to carry over any static properties
        $.extend( constructor, existingConstructor, {
            version: prototype.version,

            // Copy the object used to create the prototype in case we need to
            // redefine the widget later
            _proto: $.extend( {}, prototype ),

            // Track widgets that inherit from this widget in case this widget is
            // redefined after a widget inherits from it
            _childConstructors: []
        } );

        basePrototype = new base();

        // We need to make the options hash a property directly on the new instance
        // otherwise we'll modify the options hash on the prototype that we're
        // inheriting from
        basePrototype.options = $.widget.extend( {}, basePrototype.options );
        $.each( prototype, function( prop, value ) {
            if ( typeof value !== "function" ) {
                proxiedPrototype[ prop ] = value;
                return;
            }
            proxiedPrototype[ prop ] = ( function() {
                function _super() {
                    return base.prototype[ prop ].apply( this, arguments );
                }

                function _superApply( args ) {
                    return base.prototype[ prop ].apply( this, args );
                }

                return function() {
                    var __super = this._super;
                    var __superApply = this._superApply;
                    var returnValue;

                    this._super = _super;
                    this._superApply = _superApply;

                    returnValue = value.apply( this, arguments );

                    this._super = __super;
                    this._superApply = __superApply;

                    return returnValue;
                };
            } )();
        } );
        constructor.prototype = $.widget.extend( basePrototype, {

            // TODO: remove support for widgetEventPrefix
            // always use the name + a colon as the prefix, e.g., draggable:start
            // don't prefix for widgets that aren't DOM-based
            widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name
        }, proxiedPrototype, {
            constructor: constructor,
            namespace: namespace,
            widgetName: name,
            widgetFullName: fullName
        } );

        // If this widget is being redefined then we need to find all widgets that
        // are inheriting from it and redefine all of them so that they inherit from
        // the new version of this widget. We're essentially trying to replace one
        // level in the prototype chain.
        if ( existingConstructor ) {
            $.each( existingConstructor._childConstructors, function( i, child ) {
                var childPrototype = child.prototype;

                // Redefine the child widget using the same prototype that was
                // originally used, but inherit from the new version of the base
                $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
                    child._proto );
            } );

            // Remove the list of existing child constructors from the old constructor
            // so the old child constructors can be garbage collected
            delete existingConstructor._childConstructors;
        } else {
            base._childConstructors.push( constructor );
        }

        $.widget.bridge( name, constructor );

        return constructor;
    };

    $.widget.extend = function( target ) {
        var input = widgetSlice.call( arguments, 1 );
        var inputIndex = 0;
        var inputLength = input.length;
        var key;
        var value;

        for ( ; inputIndex < inputLength; inputIndex++ ) {
            for ( key in input[ inputIndex ] ) {
                value = input[ inputIndex ][ key ];
                if ( widgetHasOwnProperty.call( input[ inputIndex ], key ) && value !== undefined ) {

                    // Clone objects
                    if ( $.isPlainObject( value ) ) {
                        target[ key ] = $.isPlainObject( target[ key ] ) ?
                            $.widget.extend( {}, target[ key ], value ) :

                            // Don't extend strings, arrays, etc. with objects
                            $.widget.extend( {}, value );

                        // Copy everything else by reference
                    } else {
                        target[ key ] = value;
                    }
                }
            }
        }
        return target;
    };

    $.widget.bridge = function( name, object ) {
        var fullName = object.prototype.widgetFullName || name;
        $.fn[ name ] = function( options ) {
            var isMethodCall = typeof options === "string";
            var args = widgetSlice.call( arguments, 1 );
            var returnValue = this;

            if ( isMethodCall ) {

                // If this is an empty collection, we need to have the instance method
                // return undefined instead of the jQuery instance
                if ( !this.length && options === "instance" ) {
                    returnValue = undefined;
                } else {
                    this.each( function() {
                        var methodValue;
                        var instance = $.data( this, fullName );

                        if ( options === "instance" ) {
                            returnValue = instance;
                            return false;
                        }

                        if ( !instance ) {
                            return $.error( "cannot call methods on " + name +
                                " prior to initialization; " +
                                "attempted to call method '" + options + "'" );
                        }

                        if ( typeof instance[ options ] !== "function" ||
                            options.charAt( 0 ) === "_" ) {
                            return $.error( "no such method '" + options + "' for " + name +
                                " widget instance" );
                        }

                        methodValue = instance[ options ].apply( instance, args );

                        if ( methodValue !== instance && methodValue !== undefined ) {
                            returnValue = methodValue && methodValue.jquery ?
                                returnValue.pushStack( methodValue.get() ) :
                                methodValue;
                            return false;
                        }
                    } );
                }
            } else {

                // Allow multiple hashes to be passed on init
                if ( args.length ) {
                    options = $.widget.extend.apply( null, [ options ].concat( args ) );
                }

                this.each( function() {
                    var instance = $.data( this, fullName );
                    if ( instance ) {
                        instance.option( options || {} );
                        if ( instance._init ) {
                            instance._init();
                        }
                    } else {
                        $.data( this, fullName, new object( options, this ) );
                    }
                } );
            }

            return returnValue;
        };
    };

    $.Widget = function( /* options, element */ ) {};
    $.Widget._childConstructors = [];

    $.Widget.prototype = {
        widgetName: "widget",
        widgetEventPrefix: "",
        defaultElement: "<div>",

        options: {
            classes: {},
            disabled: false,

            // Callbacks
            create: null
        },

        _createWidget: function( options, element ) {
            element = $( element || this.defaultElement || this )[ 0 ];
            this.element = $( element );
            this.uuid = widgetUuid++;
            this.eventNamespace = "." + this.widgetName + this.uuid;

            this.bindings = $();
            this.hoverable = $();
            this.focusable = $();
            this.classesElementLookup = {};

            if ( element !== this ) {
                $.data( element, this.widgetFullName, this );
                this._on( true, this.element, {
                    remove: function( event ) {
                        if ( event.target === element ) {
                            this.destroy();
                        }
                    }
                } );
                this.document = $( element.style ?

                    // Element within the document
                    element.ownerDocument :

                    // Element is window or document
                    element.document || element );
                this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );
            }

            this.options = $.widget.extend( {},
                this.options,
                this._getCreateOptions(),
                options );

            this._create();

            if ( this.options.disabled ) {
                this._setOptionDisabled( this.options.disabled );
            }

            this._trigger( "create", null, this._getCreateEventData() );
            this._init();
        },

        _getCreateOptions: function() {
            return {};
        },

        _getCreateEventData: $.noop,

        _create: $.noop,

        _init: $.noop,

        destroy: function() {
            var that = this;

            this._destroy();
            $.each( this.classesElementLookup, function( key, value ) {
                that._removeClass( value, key );
            } );

            // We can probably remove the unbind calls in 2.0
            // all event bindings should go through this._on()
            this.element
                .off( this.eventNamespace )
                .removeData( this.widgetFullName );
            this.widget()
                .off( this.eventNamespace )
                .removeAttr( "aria-disabled" );

            // Clean up events and states
            this.bindings.off( this.eventNamespace );
        },

        _destroy: $.noop,

        widget: function() {
            return this.element;
        },

        option: function( key, value ) {
            var options = key;
            var parts;
            var curOption;
            var i;

            if ( arguments.length === 0 ) {

                // Don't return a reference to the internal hash
                return $.widget.extend( {}, this.options );
            }

            if ( typeof key === "string" ) {

                // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
                options = {};
                parts = key.split( "." );
                key = parts.shift();
                if ( parts.length ) {
                    curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
                    for ( i = 0; i < parts.length - 1; i++ ) {
                        curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
                        curOption = curOption[ parts[ i ] ];
                    }
                    key = parts.pop();
                    if ( arguments.length === 1 ) {
                        return curOption[ key ] === undefined ? null : curOption[ key ];
                    }
                    curOption[ key ] = value;
                } else {
                    if ( arguments.length === 1 ) {
                        return this.options[ key ] === undefined ? null : this.options[ key ];
                    }
                    options[ key ] = value;
                }
            }

            this._setOptions( options );

            return this;
        },

        _setOptions: function( options ) {
            var key;

            for ( key in options ) {
                this._setOption( key, options[ key ] );
            }

            return this;
        },

        _setOption: function( key, value ) {
            if ( key === "classes" ) {
                this._setOptionClasses( value );
            }

            this.options[ key ] = value;

            if ( key === "disabled" ) {
                this._setOptionDisabled( value );
            }

            return this;
        },

        _setOptionClasses: function( value ) {
            var classKey, elements, currentElements;

            for ( classKey in value ) {
                currentElements = this.classesElementLookup[ classKey ];
                if ( value[ classKey ] === this.options.classes[ classKey ] ||
                    !currentElements ||
                    !currentElements.length ) {
                    continue;
                }

                // We are doing this to create a new jQuery object because the _removeClass() call
                // on the next line is going to destroy the reference to the current elements being
                // tracked. We need to save a copy of this collection so that we can add the new classes
                // below.
                elements = $( currentElements.get() );
                this._removeClass( currentElements, classKey );

                // We don't use _addClass() here, because that uses this.options.classes
                // for generating the string of classes. We want to use the value passed in from
                // _setOption(), this is the new value of the classes option which was passed to
                // _setOption(). We pass this value directly to _classes().
                elements.addClass( this._classes( {
                    element: elements,
                    keys: classKey,
                    classes: value,
                    add: true
                } ) );
            }
        },

        _setOptionDisabled: function( value ) {
            this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );

            // If the widget is becoming disabled, then nothing is interactive
            if ( value ) {
                this._removeClass( this.hoverable, null, "ui-state-hover" );
                this._removeClass( this.focusable, null, "ui-state-focus" );
            }
        },

        enable: function() {
            return this._setOptions( { disabled: false } );
        },

        disable: function() {
            return this._setOptions( { disabled: true } );
        },

        _classes: function( options ) {
            var full = [];
            var that = this;

            options = $.extend( {
                element: this.element,
                classes: this.options.classes || {}
            }, options );

            function bindRemoveEvent() {
                var nodesToBind = [];

                options.element.each( function( _, element ) {
                    var isTracked = $.map( that.classesElementLookup, function( elements ) {
                        return elements;
                    } )
                        .some( function( elements ) {
                            return elements.is( element );
                        } );

                    if ( !isTracked ) {
                        nodesToBind.push( element );
                    }
                } );

                that._on( $( nodesToBind ), {
                    remove: "_untrackClassesElement"
                } );
            }

            function processClassString( classes, checkOption ) {
                var current, i;
                for ( i = 0; i < classes.length; i++ ) {
                    current = that.classesElementLookup[ classes[ i ] ] || $();
                    if ( options.add ) {
                        bindRemoveEvent();
                        current = $( $.uniqueSort( current.get().concat( options.element.get() ) ) );
                    } else {
                        current = $( current.not( options.element ).get() );
                    }
                    that.classesElementLookup[ classes[ i ] ] = current;
                    full.push( classes[ i ] );
                    if ( checkOption && options.classes[ classes[ i ] ] ) {
                        full.push( options.classes[ classes[ i ] ] );
                    }
                }
            }

            if ( options.keys ) {
                processClassString( options.keys.match( /\S+/g ) || [], true );
            }
            if ( options.extra ) {
                processClassString( options.extra.match( /\S+/g ) || [] );
            }

            return full.join( " " );
        },

        _untrackClassesElement: function( event ) {
            var that = this;
            $.each( that.classesElementLookup, function( key, value ) {
                if ( $.inArray( event.target, value ) !== -1 ) {
                    that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
                }
            } );

            this._off( $( event.target ) );
        },

        _removeClass: function( element, keys, extra ) {
            return this._toggleClass( element, keys, extra, false );
        },

        _addClass: function( element, keys, extra ) {
            return this._toggleClass( element, keys, extra, true );
        },

        _toggleClass: function( element, keys, extra, add ) {
            add = ( typeof add === "boolean" ) ? add : extra;
            var shift = ( typeof element === "string" || element === null ),
                options = {
                    extra: shift ? keys : extra,
                    keys: shift ? element : keys,
                    element: shift ? this.element : element,
                    add: add
                };
            options.element.toggleClass( this._classes( options ), add );
            return this;
        },

        _on: function( suppressDisabledCheck, element, handlers ) {
            var delegateElement;
            var instance = this;

            // No suppressDisabledCheck flag, shuffle arguments
            if ( typeof suppressDisabledCheck !== "boolean" ) {
                handlers = element;
                element = suppressDisabledCheck;
                suppressDisabledCheck = false;
            }

            // No element argument, shuffle and use this.element
            if ( !handlers ) {
                handlers = element;
                element = this.element;
                delegateElement = this.widget();
            } else {
                element = delegateElement = $( element );
                this.bindings = this.bindings.add( element );
            }

            $.each( handlers, function( event, handler ) {
                function handlerProxy() {

                    // Allow widgets to customize the disabled handling
                    // - disabled as an array instead of boolean
                    // - disabled class as method for disabling individual parts
                    if ( !suppressDisabledCheck &&
                        ( instance.options.disabled === true ||
                            $( this ).hasClass( "ui-state-disabled" ) ) ) {
                        return;
                    }
                    return ( typeof handler === "string" ? instance[ handler ] : handler )
                        .apply( instance, arguments );
                }

                // Copy the guid so direct unbinding works
                if ( typeof handler !== "string" ) {
                    handlerProxy.guid = handler.guid =
                        handler.guid || handlerProxy.guid || $.guid++;
                }

                var match = event.match( /^([\w:-]*)\s*(.*)$/ );
                var eventName = match[ 1 ] + instance.eventNamespace;
                var selector = match[ 2 ];

                if ( selector ) {
                    delegateElement.on( eventName, selector, handlerProxy );
                } else {
                    element.on( eventName, handlerProxy );
                }
            } );
        },

        _off: function( element, eventName ) {
            eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
                this.eventNamespace;
            element.off( eventName );

            // Clear the stack to avoid memory leaks (#10056)
            this.bindings = $( this.bindings.not( element ).get() );
            this.focusable = $( this.focusable.not( element ).get() );
            this.hoverable = $( this.hoverable.not( element ).get() );
        },

        _delay: function( handler, delay ) {
            function handlerProxy() {
                return ( typeof handler === "string" ? instance[ handler ] : handler )
                    .apply( instance, arguments );
            }
            var instance = this;
            return setTimeout( handlerProxy, delay || 0 );
        },

        _hoverable: function( element ) {
            this.hoverable = this.hoverable.add( element );
            this._on( element, {
                mouseenter: function( event ) {
                    this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
                },
                mouseleave: function( event ) {
                    this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
                }
            } );
        },

        _focusable: function( element ) {
            this.focusable = this.focusable.add( element );
            this._on( element, {
                focusin: function( event ) {
                    this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
                },
                focusout: function( event ) {
                    this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
                }
            } );
        },

        _trigger: function( type, event, data ) {
            var prop, orig;
            var callback = this.options[ type ];

            data = data || {};
            event = $.Event( event );
            event.type = ( type === this.widgetEventPrefix ?
                type :
                this.widgetEventPrefix + type ).toLowerCase();

            // The original event may come from any element
            // so we need to reset the target on the new event
            event.target = this.element[ 0 ];

            // Copy original event properties over to the new event
            orig = event.originalEvent;
            if ( orig ) {
                for ( prop in orig ) {
                    if ( !( prop in event ) ) {
                        event[ prop ] = orig[ prop ];
                    }
                }
            }

            this.element.trigger( event, data );
            return !( typeof callback === "function" &&
                callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||
                event.isDefaultPrevented() );
        }
    };

    $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
        $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
            if ( typeof options === "string" ) {
                options = { effect: options };
            }

            var hasOptions;
            var effectName = !options ?
                method :
                options === true || typeof options === "number" ?
                    defaultEffect :
                    options.effect || defaultEffect;

            options = options || {};
            if ( typeof options === "number" ) {
                options = { duration: options };
            } else if ( options === true ) {
                options = {};
            }

            hasOptions = !$.isEmptyObject( options );
            options.complete = callback;

            if ( options.delay ) {
                element.delay( options.delay );
            }

            if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
                element[ method ]( options );
            } else if ( effectName !== method && element[ effectName ] ) {
                element[ effectName ]( options.duration, options.easing, callback );
            } else {
                element.queue( function( next ) {
                    $( this )[ method ]();
                    if ( callback ) {
                        callback.call( element[ 0 ] );
                    }
                    next();
                } );
            }
        };
    } );

    var widget = $.widget;
}));
!function(n,r){"object"==typeof exports&&"undefined"!=typeof module?module.exports=r():"function"==typeof define&&define.amd?define("underscore",r):(n="undefined"!=typeof globalThis?globalThis:n||self,function(){var t=n._,e=n._=r();e.noConflict=function(){return n._=t,e}}())}(this,(function(){
//     Underscore.js 1.13.6
//     https://underscorejs.org
//     (c) 2009-2022 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors
//     Underscore may be freely distributed under the MIT license.
var n="1.13.6",r="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||Function("return this")()||{},t=Array.prototype,e=Object.prototype,u="undefined"!=typeof Symbol?Symbol.prototype:null,o=t.push,i=t.slice,a=e.toString,f=e.hasOwnProperty,c="undefined"!=typeof ArrayBuffer,l="undefined"!=typeof DataView,s=Array.isArray,p=Object.keys,v=Object.create,h=c&&ArrayBuffer.isView,y=isNaN,d=isFinite,g=!{toString:null}.propertyIsEnumerable("toString"),b=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"],m=Math.pow(2,53)-1;function j(n,r){return r=null==r?n.length-1:+r,function(){for(var t=Math.max(arguments.length-r,0),e=Array(t),u=0;u<t;u++)e[u]=arguments[u+r];switch(r){case 0:return n.call(this,e);case 1:return n.call(this,arguments[0],e);case 2:return n.call(this,arguments[0],arguments[1],e)}var o=Array(r+1);for(u=0;u<r;u++)o[u]=arguments[u];return o[r]=e,n.apply(this,o)}}function _(n){var r=typeof n;return"function"===r||"object"===r&&!!n}function w(n){return void 0===n}function A(n){return!0===n||!1===n||"[object Boolean]"===a.call(n)}function x(n){var r="[object "+n+"]";return function(n){return a.call(n)===r}}var S=x("String"),O=x("Number"),M=x("Date"),E=x("RegExp"),B=x("Error"),N=x("Symbol"),I=x("ArrayBuffer"),T=x("Function"),k=r.document&&r.document.childNodes;"function"!=typeof/./&&"object"!=typeof Int8Array&&"function"!=typeof k&&(T=function(n){return"function"==typeof n||!1});var D=T,R=x("Object"),F=l&&R(new DataView(new ArrayBuffer(8))),V="undefined"!=typeof Map&&R(new Map),P=x("DataView");var q=F?function(n){return null!=n&&D(n.getInt8)&&I(n.buffer)}:P,U=s||x("Array");function W(n,r){return null!=n&&f.call(n,r)}var z=x("Arguments");!function(){z(arguments)||(z=function(n){return W(n,"callee")})}();var L=z;function $(n){return O(n)&&y(n)}function C(n){return function(){return n}}function K(n){return function(r){var t=n(r);return"number"==typeof t&&t>=0&&t<=m}}function J(n){return function(r){return null==r?void 0:r[n]}}var G=J("byteLength"),H=K(G),Q=/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;var X=c?function(n){return h?h(n)&&!q(n):H(n)&&Q.test(a.call(n))}:C(!1),Y=J("length");function Z(n,r){r=function(n){for(var r={},t=n.length,e=0;e<t;++e)r[n[e]]=!0;return{contains:function(n){return!0===r[n]},push:function(t){return r[t]=!0,n.push(t)}}}(r);var t=b.length,u=n.constructor,o=D(u)&&u.prototype||e,i="constructor";for(W(n,i)&&!r.contains(i)&&r.push(i);t--;)(i=b[t])in n&&n[i]!==o[i]&&!r.contains(i)&&r.push(i)}function nn(n){if(!_(n))return[];if(p)return p(n);var r=[];for(var t in n)W(n,t)&&r.push(t);return g&&Z(n,r),r}function rn(n,r){var t=nn(r),e=t.length;if(null==n)return!e;for(var u=Object(n),o=0;o<e;o++){var i=t[o];if(r[i]!==u[i]||!(i in u))return!1}return!0}function tn(n){return n instanceof tn?n:this instanceof tn?void(this._wrapped=n):new tn(n)}function en(n){return new Uint8Array(n.buffer||n,n.byteOffset||0,G(n))}tn.VERSION=n,tn.prototype.value=function(){return this._wrapped},tn.prototype.valueOf=tn.prototype.toJSON=tn.prototype.value,tn.prototype.toString=function(){return String(this._wrapped)};var un="[object DataView]";function on(n,r,t,e){if(n===r)return 0!==n||1/n==1/r;if(null==n||null==r)return!1;if(n!=n)return r!=r;var o=typeof n;return("function"===o||"object"===o||"object"==typeof r)&&function n(r,t,e,o){r instanceof tn&&(r=r._wrapped);t instanceof tn&&(t=t._wrapped);var i=a.call(r);if(i!==a.call(t))return!1;if(F&&"[object Object]"==i&&q(r)){if(!q(t))return!1;i=un}switch(i){case"[object RegExp]":case"[object String]":return""+r==""+t;case"[object Number]":return+r!=+r?+t!=+t:0==+r?1/+r==1/t:+r==+t;case"[object Date]":case"[object Boolean]":return+r==+t;case"[object Symbol]":return u.valueOf.call(r)===u.valueOf.call(t);case"[object ArrayBuffer]":case un:return n(en(r),en(t),e,o)}var f="[object Array]"===i;if(!f&&X(r)){if(G(r)!==G(t))return!1;if(r.buffer===t.buffer&&r.byteOffset===t.byteOffset)return!0;f=!0}if(!f){if("object"!=typeof r||"object"!=typeof t)return!1;var c=r.constructor,l=t.constructor;if(c!==l&&!(D(c)&&c instanceof c&&D(l)&&l instanceof l)&&"constructor"in r&&"constructor"in t)return!1}o=o||[];var s=(e=e||[]).length;for(;s--;)if(e[s]===r)return o[s]===t;if(e.push(r),o.push(t),f){if((s=r.length)!==t.length)return!1;for(;s--;)if(!on(r[s],t[s],e,o))return!1}else{var p,v=nn(r);if(s=v.length,nn(t).length!==s)return!1;for(;s--;)if(p=v[s],!W(t,p)||!on(r[p],t[p],e,o))return!1}return e.pop(),o.pop(),!0}(n,r,t,e)}function an(n){if(!_(n))return[];var r=[];for(var t in n)r.push(t);return g&&Z(n,r),r}function fn(n){var r=Y(n);return function(t){if(null==t)return!1;var e=an(t);if(Y(e))return!1;for(var u=0;u<r;u++)if(!D(t[n[u]]))return!1;return n!==hn||!D(t[cn])}}var cn="forEach",ln="has",sn=["clear","delete"],pn=["get",ln,"set"],vn=sn.concat(cn,pn),hn=sn.concat(pn),yn=["add"].concat(sn,cn,ln),dn=V?fn(vn):x("Map"),gn=V?fn(hn):x("WeakMap"),bn=V?fn(yn):x("Set"),mn=x("WeakSet");function jn(n){for(var r=nn(n),t=r.length,e=Array(t),u=0;u<t;u++)e[u]=n[r[u]];return e}function _n(n){for(var r={},t=nn(n),e=0,u=t.length;e<u;e++)r[n[t[e]]]=t[e];return r}function wn(n){var r=[];for(var t in n)D(n[t])&&r.push(t);return r.sort()}function An(n,r){return function(t){var e=arguments.length;if(r&&(t=Object(t)),e<2||null==t)return t;for(var u=1;u<e;u++)for(var o=arguments[u],i=n(o),a=i.length,f=0;f<a;f++){var c=i[f];r&&void 0!==t[c]||(t[c]=o[c])}return t}}var xn=An(an),Sn=An(nn),On=An(an,!0);function Mn(n){if(!_(n))return{};if(v)return v(n);var r=function(){};r.prototype=n;var t=new r;return r.prototype=null,t}function En(n){return U(n)?n:[n]}function Bn(n){return tn.toPath(n)}function Nn(n,r){for(var t=r.length,e=0;e<t;e++){if(null==n)return;n=n[r[e]]}return t?n:void 0}function In(n,r,t){var e=Nn(n,Bn(r));return w(e)?t:e}function Tn(n){return n}function kn(n){return n=Sn({},n),function(r){return rn(r,n)}}function Dn(n){return n=Bn(n),function(r){return Nn(r,n)}}function Rn(n,r,t){if(void 0===r)return n;switch(null==t?3:t){case 1:return function(t){return n.call(r,t)};case 3:return function(t,e,u){return n.call(r,t,e,u)};case 4:return function(t,e,u,o){return n.call(r,t,e,u,o)}}return function(){return n.apply(r,arguments)}}function Fn(n,r,t){return null==n?Tn:D(n)?Rn(n,r,t):_(n)&&!U(n)?kn(n):Dn(n)}function Vn(n,r){return Fn(n,r,1/0)}function Pn(n,r,t){return tn.iteratee!==Vn?tn.iteratee(n,r):Fn(n,r,t)}function qn(){}function Un(n,r){return null==r&&(r=n,n=0),n+Math.floor(Math.random()*(r-n+1))}tn.toPath=En,tn.iteratee=Vn;var Wn=Date.now||function(){return(new Date).getTime()};function zn(n){var r=function(r){return n[r]},t="(?:"+nn(n).join("|")+")",e=RegExp(t),u=RegExp(t,"g");return function(n){return n=null==n?"":""+n,e.test(n)?n.replace(u,r):n}}var Ln={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;","`":"&#x60;"},$n=zn(Ln),Cn=zn(_n(Ln)),Kn=tn.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g},Jn=/(.)^/,Gn={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},Hn=/\\|'|\r|\n|\u2028|\u2029/g;function Qn(n){return"\\"+Gn[n]}var Xn=/^\s*(\w|\$)+\s*$/;var Yn=0;function Zn(n,r,t,e,u){if(!(e instanceof r))return n.apply(t,u);var o=Mn(n.prototype),i=n.apply(o,u);return _(i)?i:o}var nr=j((function(n,r){var t=nr.placeholder,e=function(){for(var u=0,o=r.length,i=Array(o),a=0;a<o;a++)i[a]=r[a]===t?arguments[u++]:r[a];for(;u<arguments.length;)i.push(arguments[u++]);return Zn(n,e,this,this,i)};return e}));nr.placeholder=tn;var rr=j((function(n,r,t){if(!D(n))throw new TypeError("Bind must be called on a function");var e=j((function(u){return Zn(n,e,r,this,t.concat(u))}));return e})),tr=K(Y);function er(n,r,t,e){if(e=e||[],r||0===r){if(r<=0)return e.concat(n)}else r=1/0;for(var u=e.length,o=0,i=Y(n);o<i;o++){var a=n[o];if(tr(a)&&(U(a)||L(a)))if(r>1)er(a,r-1,t,e),u=e.length;else for(var f=0,c=a.length;f<c;)e[u++]=a[f++];else t||(e[u++]=a)}return e}var ur=j((function(n,r){var t=(r=er(r,!1,!1)).length;if(t<1)throw new Error("bindAll must be passed function names");for(;t--;){var e=r[t];n[e]=rr(n[e],n)}return n}));var or=j((function(n,r,t){return setTimeout((function(){return n.apply(null,t)}),r)})),ir=nr(or,tn,1);function ar(n){return function(){return!n.apply(this,arguments)}}function fr(n,r){var t;return function(){return--n>0&&(t=r.apply(this,arguments)),n<=1&&(r=null),t}}var cr=nr(fr,2);function lr(n,r,t){r=Pn(r,t);for(var e,u=nn(n),o=0,i=u.length;o<i;o++)if(r(n[e=u[o]],e,n))return e}function sr(n){return function(r,t,e){t=Pn(t,e);for(var u=Y(r),o=n>0?0:u-1;o>=0&&o<u;o+=n)if(t(r[o],o,r))return o;return-1}}var pr=sr(1),vr=sr(-1);function hr(n,r,t,e){for(var u=(t=Pn(t,e,1))(r),o=0,i=Y(n);o<i;){var a=Math.floor((o+i)/2);t(n[a])<u?o=a+1:i=a}return o}function yr(n,r,t){return function(e,u,o){var a=0,f=Y(e);if("number"==typeof o)n>0?a=o>=0?o:Math.max(o+f,a):f=o>=0?Math.min(o+1,f):o+f+1;else if(t&&o&&f)return e[o=t(e,u)]===u?o:-1;if(u!=u)return(o=r(i.call(e,a,f),$))>=0?o+a:-1;for(o=n>0?a:f-1;o>=0&&o<f;o+=n)if(e[o]===u)return o;return-1}}var dr=yr(1,pr,hr),gr=yr(-1,vr);function br(n,r,t){var e=(tr(n)?pr:lr)(n,r,t);if(void 0!==e&&-1!==e)return n[e]}function mr(n,r,t){var e,u;if(r=Rn(r,t),tr(n))for(e=0,u=n.length;e<u;e++)r(n[e],e,n);else{var o=nn(n);for(e=0,u=o.length;e<u;e++)r(n[o[e]],o[e],n)}return n}function jr(n,r,t){r=Pn(r,t);for(var e=!tr(n)&&nn(n),u=(e||n).length,o=Array(u),i=0;i<u;i++){var a=e?e[i]:i;o[i]=r(n[a],a,n)}return o}function _r(n){var r=function(r,t,e,u){var o=!tr(r)&&nn(r),i=(o||r).length,a=n>0?0:i-1;for(u||(e=r[o?o[a]:a],a+=n);a>=0&&a<i;a+=n){var f=o?o[a]:a;e=t(e,r[f],f,r)}return e};return function(n,t,e,u){var o=arguments.length>=3;return r(n,Rn(t,u,4),e,o)}}var wr=_r(1),Ar=_r(-1);function xr(n,r,t){var e=[];return r=Pn(r,t),mr(n,(function(n,t,u){r(n,t,u)&&e.push(n)})),e}function Sr(n,r,t){r=Pn(r,t);for(var e=!tr(n)&&nn(n),u=(e||n).length,o=0;o<u;o++){var i=e?e[o]:o;if(!r(n[i],i,n))return!1}return!0}function Or(n,r,t){r=Pn(r,t);for(var e=!tr(n)&&nn(n),u=(e||n).length,o=0;o<u;o++){var i=e?e[o]:o;if(r(n[i],i,n))return!0}return!1}function Mr(n,r,t,e){return tr(n)||(n=jn(n)),("number"!=typeof t||e)&&(t=0),dr(n,r,t)>=0}var Er=j((function(n,r,t){var e,u;return D(r)?u=r:(r=Bn(r),e=r.slice(0,-1),r=r[r.length-1]),jr(n,(function(n){var o=u;if(!o){if(e&&e.length&&(n=Nn(n,e)),null==n)return;o=n[r]}return null==o?o:o.apply(n,t)}))}));function Br(n,r){return jr(n,Dn(r))}function Nr(n,r,t){var e,u,o=-1/0,i=-1/0;if(null==r||"number"==typeof r&&"object"!=typeof n[0]&&null!=n)for(var a=0,f=(n=tr(n)?n:jn(n)).length;a<f;a++)null!=(e=n[a])&&e>o&&(o=e);else r=Pn(r,t),mr(n,(function(n,t,e){((u=r(n,t,e))>i||u===-1/0&&o===-1/0)&&(o=n,i=u)}));return o}var Ir=/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;function Tr(n){return n?U(n)?i.call(n):S(n)?n.match(Ir):tr(n)?jr(n,Tn):jn(n):[]}function kr(n,r,t){if(null==r||t)return tr(n)||(n=jn(n)),n[Un(n.length-1)];var e=Tr(n),u=Y(e);r=Math.max(Math.min(r,u),0);for(var o=u-1,i=0;i<r;i++){var a=Un(i,o),f=e[i];e[i]=e[a],e[a]=f}return e.slice(0,r)}function Dr(n,r){return function(t,e,u){var o=r?[[],[]]:{};return e=Pn(e,u),mr(t,(function(r,u){var i=e(r,u,t);n(o,r,i)})),o}}var Rr=Dr((function(n,r,t){W(n,t)?n[t].push(r):n[t]=[r]})),Fr=Dr((function(n,r,t){n[t]=r})),Vr=Dr((function(n,r,t){W(n,t)?n[t]++:n[t]=1})),Pr=Dr((function(n,r,t){n[t?0:1].push(r)}),!0);function qr(n,r,t){return r in t}var Ur=j((function(n,r){var t={},e=r[0];if(null==n)return t;D(e)?(r.length>1&&(e=Rn(e,r[1])),r=an(n)):(e=qr,r=er(r,!1,!1),n=Object(n));for(var u=0,o=r.length;u<o;u++){var i=r[u],a=n[i];e(a,i,n)&&(t[i]=a)}return t})),Wr=j((function(n,r){var t,e=r[0];return D(e)?(e=ar(e),r.length>1&&(t=r[1])):(r=jr(er(r,!1,!1),String),e=function(n,t){return!Mr(r,t)}),Ur(n,e,t)}));function zr(n,r,t){return i.call(n,0,Math.max(0,n.length-(null==r||t?1:r)))}function Lr(n,r,t){return null==n||n.length<1?null==r||t?void 0:[]:null==r||t?n[0]:zr(n,n.length-r)}function $r(n,r,t){return i.call(n,null==r||t?1:r)}var Cr=j((function(n,r){return r=er(r,!0,!0),xr(n,(function(n){return!Mr(r,n)}))})),Kr=j((function(n,r){return Cr(n,r)}));function Jr(n,r,t,e){A(r)||(e=t,t=r,r=!1),null!=t&&(t=Pn(t,e));for(var u=[],o=[],i=0,a=Y(n);i<a;i++){var f=n[i],c=t?t(f,i,n):f;r&&!t?(i&&o===c||u.push(f),o=c):t?Mr(o,c)||(o.push(c),u.push(f)):Mr(u,f)||u.push(f)}return u}var Gr=j((function(n){return Jr(er(n,!0,!0))}));function Hr(n){for(var r=n&&Nr(n,Y).length||0,t=Array(r),e=0;e<r;e++)t[e]=Br(n,e);return t}var Qr=j(Hr);function Xr(n,r){return n._chain?tn(r).chain():r}function Yr(n){return mr(wn(n),(function(r){var t=tn[r]=n[r];tn.prototype[r]=function(){var n=[this._wrapped];return o.apply(n,arguments),Xr(this,t.apply(tn,n))}})),tn}mr(["pop","push","reverse","shift","sort","splice","unshift"],(function(n){var r=t[n];tn.prototype[n]=function(){var t=this._wrapped;return null!=t&&(r.apply(t,arguments),"shift"!==n&&"splice"!==n||0!==t.length||delete t[0]),Xr(this,t)}})),mr(["concat","join","slice"],(function(n){var r=t[n];tn.prototype[n]=function(){var n=this._wrapped;return null!=n&&(n=r.apply(n,arguments)),Xr(this,n)}}));var Zr=Yr({__proto__:null,VERSION:n,restArguments:j,isObject:_,isNull:function(n){return null===n},isUndefined:w,isBoolean:A,isElement:function(n){return!(!n||1!==n.nodeType)},isString:S,isNumber:O,isDate:M,isRegExp:E,isError:B,isSymbol:N,isArrayBuffer:I,isDataView:q,isArray:U,isFunction:D,isArguments:L,isFinite:function(n){return!N(n)&&d(n)&&!isNaN(parseFloat(n))},isNaN:$,isTypedArray:X,isEmpty:function(n){if(null==n)return!0;var r=Y(n);return"number"==typeof r&&(U(n)||S(n)||L(n))?0===r:0===Y(nn(n))},isMatch:rn,isEqual:function(n,r){return on(n,r)},isMap:dn,isWeakMap:gn,isSet:bn,isWeakSet:mn,keys:nn,allKeys:an,values:jn,pairs:function(n){for(var r=nn(n),t=r.length,e=Array(t),u=0;u<t;u++)e[u]=[r[u],n[r[u]]];return e},invert:_n,functions:wn,methods:wn,extend:xn,extendOwn:Sn,assign:Sn,defaults:On,create:function(n,r){var t=Mn(n);return r&&Sn(t,r),t},clone:function(n){return _(n)?U(n)?n.slice():xn({},n):n},tap:function(n,r){return r(n),n},get:In,has:function(n,r){for(var t=(r=Bn(r)).length,e=0;e<t;e++){var u=r[e];if(!W(n,u))return!1;n=n[u]}return!!t},mapObject:function(n,r,t){r=Pn(r,t);for(var e=nn(n),u=e.length,o={},i=0;i<u;i++){var a=e[i];o[a]=r(n[a],a,n)}return o},identity:Tn,constant:C,noop:qn,toPath:En,property:Dn,propertyOf:function(n){return null==n?qn:function(r){return In(n,r)}},matcher:kn,matches:kn,times:function(n,r,t){var e=Array(Math.max(0,n));r=Rn(r,t,1);for(var u=0;u<n;u++)e[u]=r(u);return e},random:Un,now:Wn,escape:$n,unescape:Cn,templateSettings:Kn,template:function(n,r,t){!r&&t&&(r=t),r=On({},r,tn.templateSettings);var e=RegExp([(r.escape||Jn).source,(r.interpolate||Jn).source,(r.evaluate||Jn).source].join("|")+"|$","g"),u=0,o="__p+='";n.replace(e,(function(r,t,e,i,a){return o+=n.slice(u,a).replace(Hn,Qn),u=a+r.length,t?o+="'+\n((__t=("+t+"))==null?'':_.escape(__t))+\n'":e?o+="'+\n((__t=("+e+"))==null?'':__t)+\n'":i&&(o+="';\n"+i+"\n__p+='"),r})),o+="';\n";var i,a=r.variable;if(a){if(!Xn.test(a))throw new Error("variable is not a bare identifier: "+a)}else o="with(obj||{}){\n"+o+"}\n",a="obj";o="var __t,__p='',__j=Array.prototype.join,"+"print=function(){__p+=__j.call(arguments,'');};\n"+o+"return __p;\n";try{i=new Function(a,"_",o)}catch(n){throw n.source=o,n}var f=function(n){return i.call(this,n,tn)};return f.source="function("+a+"){\n"+o+"}",f},result:function(n,r,t){var e=(r=Bn(r)).length;if(!e)return D(t)?t.call(n):t;for(var u=0;u<e;u++){var o=null==n?void 0:n[r[u]];void 0===o&&(o=t,u=e),n=D(o)?o.call(n):o}return n},uniqueId:function(n){var r=++Yn+"";return n?n+r:r},chain:function(n){var r=tn(n);return r._chain=!0,r},iteratee:Vn,partial:nr,bind:rr,bindAll:ur,memoize:function(n,r){var t=function(e){var u=t.cache,o=""+(r?r.apply(this,arguments):e);return W(u,o)||(u[o]=n.apply(this,arguments)),u[o]};return t.cache={},t},delay:or,defer:ir,throttle:function(n,r,t){var e,u,o,i,a=0;t||(t={});var f=function(){a=!1===t.leading?0:Wn(),e=null,i=n.apply(u,o),e||(u=o=null)},c=function(){var c=Wn();a||!1!==t.leading||(a=c);var l=r-(c-a);return u=this,o=arguments,l<=0||l>r?(e&&(clearTimeout(e),e=null),a=c,i=n.apply(u,o),e||(u=o=null)):e||!1===t.trailing||(e=setTimeout(f,l)),i};return c.cancel=function(){clearTimeout(e),a=0,e=u=o=null},c},debounce:function(n,r,t){var e,u,o,i,a,f=function(){var c=Wn()-u;r>c?e=setTimeout(f,r-c):(e=null,t||(i=n.apply(a,o)),e||(o=a=null))},c=j((function(c){return a=this,o=c,u=Wn(),e||(e=setTimeout(f,r),t&&(i=n.apply(a,o))),i}));return c.cancel=function(){clearTimeout(e),e=o=a=null},c},wrap:function(n,r){return nr(r,n)},negate:ar,compose:function(){var n=arguments,r=n.length-1;return function(){for(var t=r,e=n[r].apply(this,arguments);t--;)e=n[t].call(this,e);return e}},after:function(n,r){return function(){if(--n<1)return r.apply(this,arguments)}},before:fr,once:cr,findKey:lr,findIndex:pr,findLastIndex:vr,sortedIndex:hr,indexOf:dr,lastIndexOf:gr,find:br,detect:br,findWhere:function(n,r){return br(n,kn(r))},each:mr,forEach:mr,map:jr,collect:jr,reduce:wr,foldl:wr,inject:wr,reduceRight:Ar,foldr:Ar,filter:xr,select:xr,reject:function(n,r,t){return xr(n,ar(Pn(r)),t)},every:Sr,all:Sr,some:Or,any:Or,contains:Mr,includes:Mr,include:Mr,invoke:Er,pluck:Br,where:function(n,r){return xr(n,kn(r))},max:Nr,min:function(n,r,t){var e,u,o=1/0,i=1/0;if(null==r||"number"==typeof r&&"object"!=typeof n[0]&&null!=n)for(var a=0,f=(n=tr(n)?n:jn(n)).length;a<f;a++)null!=(e=n[a])&&e<o&&(o=e);else r=Pn(r,t),mr(n,(function(n,t,e){((u=r(n,t,e))<i||u===1/0&&o===1/0)&&(o=n,i=u)}));return o},shuffle:function(n){return kr(n,1/0)},sample:kr,sortBy:function(n,r,t){var e=0;return r=Pn(r,t),Br(jr(n,(function(n,t,u){return{value:n,index:e++,criteria:r(n,t,u)}})).sort((function(n,r){var t=n.criteria,e=r.criteria;if(t!==e){if(t>e||void 0===t)return 1;if(t<e||void 0===e)return-1}return n.index-r.index})),"value")},groupBy:Rr,indexBy:Fr,countBy:Vr,partition:Pr,toArray:Tr,size:function(n){return null==n?0:tr(n)?n.length:nn(n).length},pick:Ur,omit:Wr,first:Lr,head:Lr,take:Lr,initial:zr,last:function(n,r,t){return null==n||n.length<1?null==r||t?void 0:[]:null==r||t?n[n.length-1]:$r(n,Math.max(0,n.length-r))},rest:$r,tail:$r,drop:$r,compact:function(n){return xr(n,Boolean)},flatten:function(n,r){return er(n,r,!1)},without:Kr,uniq:Jr,unique:Jr,union:Gr,intersection:function(n){for(var r=[],t=arguments.length,e=0,u=Y(n);e<u;e++){var o=n[e];if(!Mr(r,o)){var i;for(i=1;i<t&&Mr(arguments[i],o);i++);i===t&&r.push(o)}}return r},difference:Cr,unzip:Hr,transpose:Hr,zip:Qr,object:function(n,r){for(var t={},e=0,u=Y(n);e<u;e++)r?t[n[e]]=r[e]:t[n[e][0]]=n[e][1];return t},range:function(n,r,t){null==r&&(r=n||0,n=0),t||(t=r<n?-1:1);for(var e=Math.max(Math.ceil((r-n)/t),0),u=Array(e),o=0;o<e;o++,n+=t)u[o]=n;return u},chunk:function(n,r){if(null==r||r<1)return[];for(var t=[],e=0,u=n.length;e<u;)t.push(i.call(n,e,e+=r));return t},mixin:Yr,default:tn});return Zr._=Zr,Zr}));
/**
 *    xbe4x is javascript implementation of the original ECMAScript for XML (E4X)
 *    Specification (ECMA-357) December 2005. This implementation is designed to emulate
 *    the implementation that is used in SpiderMonkey (Mozilla's JavaScript(TM) Engine)
 *    and therefore Firefox, Thunderbird, and most other Gecko based applications.
 *    Because the Mozilla implementation leaves out certain features of the
 *    specification, so does xbe4x. Please read the README file for a further
 *    explanation of these issues.
 *
 *
 *    @author Sam Shull <http://samshull.blogspot.com/>
 *    @version 0.1
 *
 *    @copyright Copyright (c) 2009 Sam Shull <http://samshull.blogspot.com/>
 *    @license <http://www.opensource.org/licenses/mit-license.html>
 *
 *    Permission is hereby granted, free of charge, to any person obtaining a copy
 *    of this software and associated documentation files (the "Software"), to deal
 *    in the Software without restriction, including without limitation the rights
 *    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *    copies of the Software, and to permit persons to whom the Software is
 *    furnished to do so, subject to the following conditions:
 *
 *    The above copyright notice and this permission notice shall be included in
 *    all copies or substantial portions of the Software.
 *
 *    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *    THE SOFTWARE.
 *
 *
 *    CHANGES:
 */

//this doesn't load if window.XML is already defined
if (!this.XML)
{
    (function ()
    {
        /*
         *
         *
         */
        var undefined, p,
            window                       = this,
            dns                          = [],
            defaultNamespace             = "",
            ELEMENT_NODE                 = 1,
            ATTRIBUTE_NODE               = 2,
            TEXT_NODE                    = 3,
            CDATA_SECTION_NODE           = 4,
            ENTITY_REFERENCE_NODE        = 5,
            ENTITY_NODE                  = 6,
            PROCESSING_INSTRUCTION_NODE  = 7,
            COMMENT_NODE                 = 8,
            DOCUMENT_NODE                = 9,
            DOCUMENT_TYPE_NODE           = 10,
            DOCUMENT_FRAGMENT_NODE       = 11,
            NOTATION_NODE                = 12,
            isNSDef                      = /^xmlns:([\w\-]+)/i,
            toString                     = ({}).toString,
            propertyIsEnumerable         = ({}).propertyIsEnumerable,
            hasOwnProperty               = ({}).hasOwnProperty,
            defaultXMLProperties         = ",prototype,ignoreComments,ignoreProcessingInstructions,ignoreWhitespace," +
                "prettyPrinting,prettyIndent,settings,defaultSettings,setSettings,settings," +
                "propertyIsEnumerable,hasOwnProperty,_setDefaultNamespace,",
            defaultXMLPrototype          = ",_Class,_Name,_Parent,_Value,_InScopeNamespaces,_Attributes,_Children,_Node",
            defaultXMLListPrototype      = ",_Class,_Value,_Children,_TargetObject,_TargetProperty",
            xmlDoc                       = parse("<x/>"),
            piName                       = /^[\w\-]+\s*/,
            XSLT_NS                      = "http://www.w3.org/1999/XSL/Transform";

        /**
         *
         *
         *    @param String | XML $string
         *    @returns XML
         *    @throws SyntaxError
         */
        function XML ($string)
        {
            if (!(this instanceof XML))
            {
                return ToXML($string);
            }

            var x, i, l;

            this._Class = "text";

            this._Name = null;

            this._Value = null;

            this._Parent = null;

            this._InScopeNamespaces = {};

            this._DefaultNamespace = null;

            this._Attributes = {};

            this._Children = [];

            this[0] = this;

            /**
             *
             *
             *
             */
            switch (typeof($string))
            {
                case "undefined":
                case "null":
                    break;
                case "number":
                case "boolean":    $string = ToString($string);
                case "string":

                    x = ToXML(trim($string));
                    if (x)
                    {
                        if (x.length() ===1)
                        {
                            this._Class = x._Class;
                            this._Name = x._Name;
                            this._Value = x._Value;
                            this._InScopeNamespaces = x._InScopeNamespaces;
                            this._DefaultNamespace = x._DefaultNamespace;
                            this._Attributes = x._Attributes;

                            for (i = 0, l = x._Children.length; i < l; ++i)
                            {
                                this._Children[i] = x._Children[i];
                                this._Children[i]._Parent = this;
                            }

                            break;
                        }
                    }

                    throw new SyntaxError();
                    break;
                default:
                    if ($string instanceof XML)
                    {
                        if ($string.length() ===1)
                        {
                            x = $string;
                            this._Class = x._Class;
                            this._Name = x._Name;
                            this._Value = x._Value;
                            this._InScopeNamespaces = x._InScopeNamespaces;
                            this._DefaultNamespace = x._DefaultNamespace;
                            this._Attributes = x._Attributes;

                            for (i = 0, l = x._Children.length; i < l; ++i)
                            {
                                this._Children[i] = x._Children[i];
                                this._Children[i]._Parent = this;
                            }
                        }
                    }
                    break;
            }
        }

        /**
         *    Ignore XML comments. (Default: true.)
         *
         *    @static
         *    @param Namespace ns
         *    @returns void
         */
        XML.setDefaultNamespace = function (ns)
        {
            dns.unshift(defaultNamespace || "");
            defaultNamespace = Namespace(ns);
            return null;
        };

        /**
         *  Use this function to restore the default namespace
         *  to the previous namespace
         *
         */
        XML.restoreDefaultNamespace = function ()
        {
            defaultNamespace = dns.shift() || "";
            return null;
        };

        /**
         *
         *
         *
         */
        XML.load = function (pathToFile, onload)
        {
            var xhr = isActiveXSupported("Microsoft.XMLHTTP") && new ActiveXObject("Microsoft.XMLHTTP") || new XMLHttpRequest(),
                async = ({}).toString.call(onload || {}) == "[object Function]";

            xhr.open("GET", pathToFile, async);

            if (async)
            {
                if (!!xhr.addEventListener)
                {
                    xhr.addEventListener("load", loaded, false);
                }
                else
                {
                    xhr.onreadystatechange = function ()
                    {
                        if (xhr.readyState == 4 && xhr.status == 200)
                        {
                            loaded();
                        }
                    };
                }
            }

            xhr.send(null);

            return async ? xhr : loaded(1);

            function loaded (ret)
            {
                var x = new XML((xhr.responseText||"").replace(/\s*<\?xml.*?\?>/,""));
                return ret ? x : onload(x);
            }
        };

        /**
         *    Ignore XML comments. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreComments = true;

        /**
         *    Ignore XML processing instructions. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreProcessingInstructions = true;

        /**
         *    Ignore whitespace. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreWhitespace = true;

        /**
         *    Pretty-print XML output with toXMLString() etc. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.prettyPrinting = true;

        /**
         *    Pretty indent level for child nodes. (Default: 2.)
         *
         *    @static
         *    @var Number
         */
        XML.prettyIndent = 2;

        //There are also three methods to more easily apply and restore settings for use, say, within a function.

        /**
         *    Get an Object containing the above settings.
         *
         *    @static
         *    @returns Object
         */
        XML.settings = function ()
        {
            return {
                ignoreComments:                 XML.ignoreComments,
                ignoreProcessingInstructions:   XML.ignoreProcessingInstructions,
                ignoreWhitespace:               XML.ignoreWhitespace,
                prettyPrinting:                 XML.prettyPrinting,
                prettyIndent:                   XML.prettyIndent
            };
        };

        /**
         *    Get an object containing the default settings.
         *
         *    @static
         *    @returns Object
         */
        XML.defaultSettings = function ()
        {
            return {
                ignoreComments:                 true,
                ignoreProcessingInstructions:   true,
                ignoreWhitespace:               true,
                prettyPrinting:                 true,
                prettyIndent:                   2
            };
        };

        /**
         *    Set XML settings from, e.g., an object returned by XML.settings().
         *
         *
         *    @static
         *    @param Object settings
         *    @returns void
         */
        XML.setSettings = function (settings)
        {
            var p;
            settings = settings || XML.settings();
            for (p in settings)
            {
                switch (p)
                {
                    case "ignoreComments":                   XML.ignoreComments = !!settings[p];
                    case "ignoreProcessingInstructions":     XML.ignoreProcessingInstructions = !!settings[p];
                    case "ignoreWhitespace":                 XML.ignoreWhitespace = !!settings[p];
                    case "prettyPrinting":                   XML.prettyPrinting = !!settings[p];
                    case "prettyIndent":                     XML.prettyIndent = parseInt(settings[p]) || 0;
                }
            }
            return null;
        };

        /**
         *
         *
         *    @static
         *    @param String name
         *    @returns Boolean
         */
        XML.hasOwnProperty = function (name)
        {
            return defaultXMLProperties.indexOf("," + name + ",") ===-1
                && hasOwnProperty.call(XML, name);
        };

        /**
         *
         *
         *    @static
         *    @param String name
         *    @returns Boolean
         */
        XML.propertyIsEnumerable = function (name)
        {
            return name !== "prototype"
                && name in XML
                && toString.call(XML[name]) != "[object Function]"
                && propertyIsEnumerable.call(XML, name);
        };

        /**
         *
         *
         *    @static
         *    @returns String
         */
        XML.toString = function ()
        {
            return "function XML() {\n [native code] \n}";
        };

        /**
         *
         *
         *    @param String | Namespace namespace
         *    @returns XML
         */
        XML.prototype.addNamespace = function (namespace)
        {
            AddInScopeNamespace.call(this, Namespace(namespace));
            return this;
        };

        /**
         *
         *
         *    @param String child
         *    @returns XML
         */
        XML.prototype.appendChild = function (child,isChildElement)
        {
            isChildElement = isChildElement !== undefined ? isChildElement : false;
            var children = Get.call(this, "*");
            children.Put(children.length(), child,isChildElement);
            return this;
        };

        /**
         *
         *
         *    @param String | AttributeName | QName attributeName
         *    @returns XML
         */
        XML.prototype.attribute = function (attributeName)
        {
            return Get.call(this, ToAttributeName(attributeName), true);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.attributes = function ()
        {
            return Get.call(this, ToAttributeName("*"));
        };

        /**
         *
         *
         *    @param String propertyName
         *    @returns XMLList
         */
        XML.prototype.child = function (propertyName)
        {
            var temporary;

            if (parseInt(propertyName)+"" == propertyName)
            {
                temporary = Get.call(this, "*");
                temporary = GetList.call(temporary, propertyName);
                return temporary || new XMLList();
            }

            temporary = ToXMLList( Get.call(this, propertyName) );

            return temporary;
        };

        /**
         *
         *
         *    @returns Number
         */
        XML.prototype.childIndex = function ()
        {
            var parent = this._Parent, q, l;

            if (!parent || this._Class === "attribute")
            {
                return -1;
            }

            for (q = 0, l = parent._Children.length; q < l; ++q)
            {
                if (parent._Children[q] === this)
                {
                    return q;
                }
            }

            return -1;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.children = function ()
        {
            return Get.call(this, "*");
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.comments = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "comment")
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns Boolean
         */
        XML.prototype.contains = function (value)
        {
            return this == value;
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.copy = function ()
        {
            return DeepCopy.call(this);
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XML.prototype.descendants = function (name)
        {
            return Descendants.call(this, name || "*");
        };

        /**
         *
         *
         *    @param String | QName | AttributeName name
         *    @returns XMLList
         */
        XML.prototype.elements = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = name;

            for (; i < l; ++i)
            {
                if (
                    this._Children[i]._Class === "element"
                        && (name.localName === "*" || name.localName === this._Children[i]._Name.localName)
                        && (name.uri == null || name.uri === this._Children[i]._Name.uri)
                    )
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XML.prototype.hasOwnProperty = function (name)
        {
            return HasProperty.call(this, name) || (defaultXMLPrototype.indexOf("," + name +",") === -1 && hasOwnProperty.call(this, name));
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XML.prototype.hasComplexContent = function ()
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XML.prototype.hasSimpleContent = function ()
        {
            if ((",comment,processing-instruction,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return false;
                }
            }

            return true;
        };

        /**
         *
         *
         *    @returns Array
         */
        XML.prototype.inScopeNamespaces = function ()
        {
            var y = this, inScopeNS = {}, p, a = [];

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!inScopeNS[p])
                    {
                        inScopeNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y.parent();
            }

            if (this._DefaultNamespace)
            {
                inScopeNS[""] = this._DefaultNamespace;
            }

            for (p in inScopeNS)
            {
                a[a.length] = inScopeNS[p];
            }

            return a;
        };

        /**
         *
         *
         *    @param XML child1
         *    @param XML child2
         *    @returns XML | null
         */
        XML.prototype.insertChildAfter = function (child1, child2)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            /*
             //this is disabled, because it doesn't work in
             //Firefox according to the spec
             if (!child2)
             {
             Insert.call(this, 0, child1);
             return this;
             }
             else if (!child1)
             {
             Insert.call(this, 0, child2);
             return this;
             }
             else
             */

            if (!child1){
                Insert.call(this, 0, child2);
                return this;
            }
            if (!child2){
                Insert.call(this, 0, child1);
                return this;
            }

            if (child1 instanceof XML)
            {
                Insert.call(this, child1.childIndex() + 1, child2);
                return this;
            }

            return null;
        };

        /**
         *
         *
         *
         *    @param XML child1
         *    @param XML child2
         *    @returns XML | null
         */
        XML.prototype.insertChildBefore = function (child1, child2)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            /*
             //this is disabled, because it doesn't work in
             //Firefox according to the spec
             if (!child1)
             {
             Insert.call(this, this._Children.length, child2);
             return this;
             }
             else if (!child2)
             {
             Insert.call(this, this._Children.length, child1);
             return this;
             }
             else
             */

            if (child1 instanceof XML)
            {
                Insert.call(this, child1.childIndex(), child2);
                return this;
            }

            return null;
        };

        /**
         *
         *
         *    @returns Number
         */
        XML.prototype.length = function ()
        {
            return 1;
        };

        /**
         *
         *
         *    @returns String | null
         */
        XML.prototype.localName = function ()
        {
            return this._Name === null ? null : this._Name.localName;
        };

        /**
         *
         *
         *    return QName
         */
        XML.prototype.name = function ()
        {
            return this._Name;
        };

        /**
         *
         *
         *    @param String prefix
         *    @returns Namespace
         */
        XML.prototype.namespace = function (prefix)
        {
            var y = this, inScopeNS = {}, p;

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!inScopeNS[p])
                    {
                        inScopeNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y.parent();
            }

            if (prefix === undefined)
            {
                if ((",comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
                {
                    return null;
                }

                return GetNamespace(this._Name, inScopeNS);
            }

            prefix = ToString(prefix);

            for (p in inScopeNS)
            {
                if (inScopeNS[p].prefix === prefix)
                {
                    return inScopeNS[p];
                }
            }

            return null;
        };

        /**
         *
         *
         *    @returns Array
         */
        XML.prototype.namespaceDeclarations = function ()
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return [];
            }

            var a = [], y = this._Parent, ancestorNS = {}, p;

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!ancestorNS[p])
                    {
                        ancestorNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y._Parent;
            }

            for (p in this._InScopeNamespaces)
            {
                if (p != "" && (!ancestorNS[p] || ancestorNS[p].uri != this._InScopeNamespaces[p]))
                {
                    a[a.length] = this._InScopeNamespaces[p];
                }
                else if(p === "" && !this._Parent)
                {
                    a[a.length] = this._InScopeNamespaces[p];
                }
            }

            return a;
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.nodeKind = function ()
        {
            return this._Class;
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.normalize = function ()
        {
            for (var i = 0, l = this._Children.length; i < l;)
            {
                if (this._Children[i]._Class === "element")
                {
                    this._Children[i].normalize();
                    ++i;
                }
                else if (this._Children[i]._Class === "text")
                {
                    while (i+1 < this._Children.length && this._Children[i+1]._Class === "text")
                    {
                        this._Children[i]._Value = (this._Children[i]._Value || "") + (this._Children[i+1]._Value || "");
                        DeleteByIndex.call(this, i+1);
                    }

                    if (this._Children[i]._Value.length === 0)
                    {
                        DeleteByIndex.call(this, i);
                    }
                    else
                    {
                        ++i;
                    }
                }
                else
                {
                    ++i;
                }
            }

            return this;
        };

        /**
         *
         *
         *    @returns XML | null
         */
        XML.prototype.parent = function ()
        {
            return this._Parent;
        };

        /**
         *
         *
         *    @param String name
         *    @returns XMLList
         */
        XML.prototype.processingInstructions = function (name)
        {
            name = ToXMLName(name || "*");

            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "processing-instruction"
                    && (name.localName === "*" || name.localName === this._Children[i]._Name.localName)
                    )
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.prependChild = function (value)
        {
            Insert.call(this, 0, value);
            return this;
        };


        XML.prototype.findFirstElement = function (value)
        {
            var list = [];
            list = this.elements(value)._Children;
            if(list.length == 0){
                var children = this.children();
                var xml;
                for(var i=0;i<children.length();i++){
                    xml = children[i];
                    var sublist = xml.findFirstElement(value);
                    if(sublist.length>0)
                        return sublist;
                }
            }
            return list;
        };


        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XML.prototype.propertyIsEnumerable = function (name)
        {
            return name == "0";
        };

        /**
         *
         *
         *    @param Namespace | String namespace
         *    @returns XML
         */
        XML.prototype.removeNamespace = function (namespace)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return this;
            }

            var ns = Namespace(namespace), thisNS = GetNamespace(this._Name, this._InScopeNamespaces), p, l;

            if (thisNS == ns)
            {
                return this;
            }

            /*
             //firefox does not remove the references to the
             //namespaces in attributes -- so we wont either
             for (p in this._Attributes)
             {
             if (GetNamespace(this._Attributes[p]._Name, this._InScopeNamespaces).uri == ns.uri)
             {
             this._Attributes[p]._Name = new QName(ns, this._Attributes[p].localName());
             }
             }
             //*/

            if (ns.prefix == undefined)
            {
                for (p in this._InScopeNamespaces)
                {
                    if (this._InScopeNamespaces[p].uri === ns.uri)
                    {
                        try{
                            this._InScopeNamespaces[p] = null;
                            delete this._InScopeNamespaces[p];
                        }catch(e){}
                    }
                }
            }
            else if (this._InScopeNamespaces[ns.prefix] && this._InScopeNamespaces[ns.prefix].uri === ns.uri)
            {
                try{
                    this._InScopeNamespaces[ns.prefix] = null;
                    delete this._InScopeNamespaces[ns.prefix];
                }catch(e){}
            }

            for (p = 0, l = this._Children.length; p < l; ++p)
            {
                if (this._Children[p]._Class === "element")
                {
                    this._Children[p].removeNamespace(ns);
                }
            }

            return this;
        };

        /**
         *
         *
         *    @param String propertyName
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.replace = function (propertyName, value)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return this;
            }

            var c = value instanceof XML ? DeepCopy.call(value) : ToString(value), n, i, k;

            if (parseInt(propertyName)+"" == propertyName)
            {
                Replace.call(this, propertyName, c);
                return this;
            }

            /*
             Basically Firefox does not appear to follow the rules set forth in the spec
             so, we are just going to fix this so that we do what firefox does
             if the propertyName is not an integer:
             if value is a XMLList setChildren
             otherwise do nothing
             */

            if (c instanceof XMLList)
            {
                this.setChildren(c);
            }

            return this;

            /*
             Leave the rest of these rules in place, just in case
             */

            n = QName(propertyName);
            k = this._Children.length;

            while (--k > -1)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName===n.localName))
                        && (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri ))
                    )
                {
                    if (i !== undefined)
                    {
                        DeleteByIndex.call(this, i);
                    }

                    i = k;
                }
            }

            if (i !== undefined)
            {
                Replace.call(this, i, c);
            }

            return this;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.setChildren = function (value)
        {
            this.Put("*", value);
            return this;
        };

        /**
         *
         *
         *    @param String name
         *    @returns void
         */
        XML.prototype.setLocalName = function (name)
        {
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._Name.localName = name instanceof QName ? name.localName : ToString(name);
        };

        /**
         *
         *
         *    @param QName | String name
         *    @returns null
         */
        XML.prototype.setName = function (name)
        {
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            if (name instanceof QName && name.uri == null)
            {
                name = name.localName;
            }

            var n = QName(name);

            if (this._Class === "processing-instruction")
            {
                n.uri = "";
            }

            this._DefaultNamespace = new Namespace(n.prefix, n.uri);

            this._Name = n;

            if (this._Class === "attribute")
            {
                if (this._Parent)
                {
                    AddInScopeNamespace.call(this._Parent, this._DefaultNamespace);
                }
            }
            else if (this._Class === "element")
            {
                AddInScopeNamespace.call(this, this._DefaultNamespace);
            }
            else if ((",comment,text,processing-instruction,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._Name = new QName(this._DefaultNamespace, this._Name.localName);

            return null;
        };

        /**
         *
         *
         *    @param Namespace | String ns
         *    @returns null
         */
        XML.prototype.setNamespace = function (ns)
        {
            //processing-instruction,
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._DefaultNamespace = Namespace(ns);

            this._Name = new QName(this._DefaultNamespace, this._Name.localName);

            if (this._Class === "attribute")
            {
                if (this._Parent)
                {
                    AddInScopeNamespace.call(this._Parent, this._DefaultNamespace);
                }
            }
            else if (this._Class === "element")
            {
                AddInScopeNamespace.call(this, this._DefaultNamespace);
            }

            return null;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.text = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "text")
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.toString = function ()
        {
            return ToString(this);
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.toXMLString = function ()
        {
            return ToXMLString(this);
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.valueOf = function ()
        {
            return this;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML | String Value
         *    @returns null
         *    @throws TypeError
         */
        XML.prototype.Put = function (PropertyName, Value)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                throw new TypeError();
            }

            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var c = (!(Value instanceof XML) || (",text,attribute,").indexOf("," + Value._Class+",") > -1)
                    ? ToString(Value)
                    : DeepCopy.call(Value),
                n = ToXMLName(PropertyName),
                s, i, l, a = null, primitiveAssign, k;

            if (n instanceof AttributeName)
            {
                if (!isXMLName(n._Name))
                {
                    return false;
                }

                if (c instanceof XMLList)
                {
                    if (c._Children.length === 0)
                    {
                        c = "";
                    }
                    else
                    {
                        s = ToString(c[0]);

                        for (i = 1, l = c._Children.length; i < l; ++i)
                        {
                            s += " " + ToString(c[i]);
                        }

                        c = s;
                    }
                }
                else
                {
                    c = ToString(c);
                }

                for (i in this._Attributes)
                {
                    if (
                        (n._Name.localName === this._Attributes[i]._Name.localName)
                            && (n._Name.uri === null || n._Name.uri === this._Attributes[i]._Name.uri)
                        )
                    {
                        if (a == null)
                        {
                            a = this._Attributes[i];
                        }
                        else
                        {
                            this.Delete(this._Attributes[i]._Name);
                        }
                    }
                }

                if (a == null)
                {
                    a = new XML();
                    a._Parent = this;
                    a._Class = "attribute";
                    a._Name = n._Name.uri == null
                        ? new QName(new Namespace(), n._Name)
                        : new QName(new Namespace(n._Name.uri), n._Name.localName);

                    this._Attributes[(a._Name._Prefix ? a._Name._Prefix + ":" : "") + a._Name.localName] = a;

                    AddInScopeNamespace.call(this, GetNamespace(a._Name));
                }

                a._Value = c;

                return null;
            }

            if (!isXMLName(n) && n.localName != "*")
            {
                return null;
            }

            i = undefined;

            primitiveAssign = !(c instanceof XML) && n.localName != "*";

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName===n.localName))
                        &&
                        (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                    )
                {
                    if (i != undefined)
                    {
                        DeleteByIndex.call(this, ToString(i));
                    }
                    else
                    {
                        i = k;
                    }
                }
            }

            if (i == undefined)
            {
                i = this._Children.length;

                if (primitiveAssign)
                {
                    a = new XML();
                    a._Class = "element";
                    a._Parent = this;
                    a._Name = n.uri == null
                        ? new QName(GetDefaultNamespace(), n)
                        : new QName(n);

                    Replace.call(this, ToString(i), a);

                    AddInScopeNamespace.call(a, GetNamespace(a._Name));
                }
            }

            if (primitiveAssign)
            {
                s = ToString(c);

                if (s != "")
                {
                    Replace.call(this._Children[i], "0", s);
                }
            }
            else
            {
                Replace.call(this, ToString(i), c);
            }

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns null
         *    @throws TypeError
         */
        XML.prototype.Delete = function (PropertyName)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                throw new TypeError();
            }

            var n = ToXMLName(PropertyName), k, dp = 0, q = 0, l;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName)
                            &&
                            (n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri)
                        )
                    {
                        this._Attributes[k]._Parent = null;
                        try{
                            delete this._Attributes[k];
                        }catch(e){}
                    }
                }

                return true;
            }

            for (l = this._Children.length; q < l; ++q)
            {
                if (
                    (n.localName === "*" || (this._Children[q]._Class === "element" && this._Children[q]._Name.localName === n.localName))
                        &&
                        (n.uri == null || (this._Children[q]._Class === "element" && n.uri === this._Children[q]._Name.uri))
                    )
                {
                    DeleteByIndex.call(this, q);
                    ++dp;
                }
                else if (dp > 0)
                {
                    this._Children[q - dp] = this._Children[q];
                }
            }


            return true;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns Boolean
         */
        XML.prototype.Equals = function (Value)
        {
            if (!(Value instanceof XML))
            {
                return false;
            }
            if (this._Class !== Value._Class)
            {
                return false;
            }
            if (this._Children.length !== Value._Children.length)
            {
                return false;
            }
            if (this._Value !== Value._Value)
            {
                return false;
            }
            if (this._Name !== null)
            {
                if (Value._Name === null)
                {
                    return false;
                }
                if (Value._Name.localName !== this._Name.localName)
                {
                    return false;
                }
                if (Value._Name.uri !== this._Name.uri)
                {
                    return false;
                }
            }
            else if (Value._Name !== null)
            {
                return false;
            }

            if (count(this._Attributes) !== count(Value._Attributes))
            {
                return false;
            }

            var a, b, k, l;

            for (k in this._Attributes)
            {
                a = this._Attributes[k];

                b = Value._Attributes[k];

                if (!b || b._Name.localName !== a._Name.localName || b._Name.uri !== a._Name.uri || b._Value !== a._Value)
                {
                    return false;
                }
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                a = this._Children[k];

                b = Value._Children[k];

                if (!arguments.callee.call(a, b))
                {
                    return false;
                }
            }

            return true;
        };

        //extensions

        /*
         * e4x.js
         *
         * A JavaScript library that implements the optional E4X features described in
         * ECMA-357 2nd Edition Annex A if they are not already implemented.
         *
         * 2010-03-13
         *
         * By Elijah Grey, http://eligrey.com
         * License: The X11/MIT license (see COPYING.md)
         *
         * Changes:
         *    By Sam Shull, http://samshull.blogspot.com
         *    Just a litlle simplifying for implementation
         */

        /*global document, XML, XMLList, DOMParser, XMLSerializer, XPathResult */

        /*jslint undef: true, nomen: true, eqeqeq: true, bitwise: true, regexp: true,
         newcap: true, immed: true, maxerr: 1000, maxlen: 90 */

        /**
         *
         *
         *
         */
        XML.prototype.domNode = function ()
        {
            return adoptNode(document, xmlToDomNode(this));
        };

        /**
         *
         *
         *
         */
        XML.prototype.domNodeList = function ()
        {
            if (this.length() < 0)
            {
                throw new Error();
            }

            return adoptNode(document, createDocumentFrom(this).documentElement).childNodes;
        };

        /**
         *
         *
         *
         */
        XML.prototype.xpath = function (xpathExp)
        {
            var res = new XMLList,
                i = 0, l = this.length(),
                xpr;

            if (l !== 1)
            {
                for (; i < l; ++i)
                {
                    res.Append(this[i].xpath(xpathExp));
                }

                return res;
            }

            xpr = evaluate(createDocumentFrom(this), xpathExp, this);

            for (l=xpr.length; i < l; ++i)
            {
                res.Append(ToXML(xpr[i]));
            }

            return res;
        };

        /**
         *
         *
         *
         */
        XML.prototype.transform = function (xslt, params)
        {
            if (!xslt instanceof XML)
            {
                throw new TypeError();
            }

            var doc, res, i, l = this.length(), c;

            if (l > 1)
            {
                res = new XMLList();
                for (i = 0; i < l; ++i)
                {
                    res.Append(this[i].transform(xslt, params));
                }
                return res;
            }

            return transform(this, xslt, params);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        function XMLList ($string)
        {
            if (!(this instanceof XMLList))
            {
                return ToXMLList($string || "");
            }

            this._Class = "XMLList";

            this._Value = undefined;


            this._TargetObject = null;

            this._TargetProperty = null;

            this._Children = [];

            this[0] = null;

            if ($string)
            {
                var list = ToXMLList($string), i = 0, l = list._Children.length;
                this._Value = list._Value;

                for (;i < l; ++i)
                {
                    this._Children[i] = this[i] = list._Children[i];
                }
            }
        }

        /**
         *
         *
         *    @static
         *    @returns String
         *    @throws TypeError
         */
        XMLList.toString = function ()
        {
            return "function XMLList() {\n [native code] \n}";
        };

        XMLList.prototype = new XML();

        var ignore = {xpath:1,domNodeList:1,transform:1};

        for (p in XMLList.prototype)
        {
            if (ignore[p])
            {
                continue;
            }

            XMLList.prototype[p] = (function(p)
            {
                return function ()
                {
                    if (this._Children.length != 1)
                    {
                        throw new TypeError("cannot call " + p + " method on an XML list with " + this._Children.length + " elements");
                    }

                    return XML.prototype[p].apply(this[0], arguments);
                };
            })(p);
        }

        try{
            delete XMLList.prototype._Attributes;
            delete XMLList.prototype._InScopeNamespaces;
        }catch(e){}

        /**
         *
         *
         *    @param String | AttributeName attributeName
         *    @returns XMLList
         */
        XMLList.prototype.attribute = function (attributeName)
        {
            return GetList.call(this, ToAttributeName(attributeName));
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.attributes = function ()
        {
            return GetList.call(this, ToAttributeName("*"));
        };

        /**
         *
         *
         *    @param String | QName propertyName
         *    @returns XMLList
         */
        XMLList.prototype.child = function (propertyName)
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                r = this[i].child(propertyName);

                if (r._Children.length > 0)
                {
                    list.Append(r);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.children = function ()
        {
            return GetList.call(this, "*");
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.comments = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].comments();

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns Boolean
         */
        XMLList.prototype.contains = function (value)
        {
            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this[i] == value)
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.copy = function ()
        {
            return DeepCopyList.call(this);
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.descendants = function (name)
        {
            return DescendantsList.call(this, name || "*");
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.elements = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;
            list._TargetProperty = name;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].elements(name);

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XMLList.prototype.hasOwnProperty = function (name)
        {
            return HasProperty.call(this, name)
                || (defaultXMLListProperties.indexOf("," + name + ",") === -1 && hasOwnProperty.call(this, name));
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XMLList.prototype.hasComplexContent = function ()
        {
            if (this._Children.length === 0)
            {
                return false;
            }

            if (this._Children.length === 1)
            {
                return this[0].hasComplexContent();
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XMLList.prototype.hasSimpleContent = function ()
        {
            if (this._Children.length === 1)
            {
                return this[0].hasSimpleContent();
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return false;
                }
            }

            return true;
        };

        /**
         *
         *
         *    @returns Number
         */
        XMLList.prototype.length = function ()
        {
            return this._Children.length;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.normalize = function ()
        {
            for (var i = 0, l = this._Children.length; i < l;)
            {
                if (this[i]._Class === "element")
                {
                    this[i].normalize();
                    ++i;
                }
                else if (this[i]._Class === "text")
                {
                    while (i+1 < this._Children.length && this[i+1]._Class === "text")
                    {
                        this[i]._Value = (this[i]._Value || "") + (this[i+1]._Value || "");
                        this.Delete(i+1);
                    }

                    if (this[i]._Value.length === 0)
                    {
                        this.Delete(i);
                    }
                    else
                    {
                        ++i;
                    }
                }
                else
                {
                    ++i;
                }
            }

            return this;
        };

        /**
         *
         *
         *    @returns XML | undefined
         */
        XMLList.prototype.parent = function ()
        {
            if (this._Children.length === 0)
            {
                return undefined;
            }

            for (var parent = this[0]._Parent, i = 1, l = this._Children.length; i < l; ++i)
            {
                if (this[i]._Parent != parent)
                {
                    return undefined;
                }
            }

            return parent;
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.processingInstructions = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].processingInstructions(name);

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String | Number name
         *    @returns Boolean
         */
        XMLList.prototype.propertyIsEnumerable = function (name)
        {
            return parseInt(name) > 0 && parseInt(name) < this._Children.length;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.text = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].text();

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns String
         */
        XMLList.prototype.toString = function ()
        {
            return ToString(this);
        };

        /**
         *
         *
         *    @returns String
         */
        XMLList.prototype.toXMLString = function ()
        {
            return ToXMLString(this);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.valueOf = function ()
        {
            return this;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @param XML Value
         *    @param isElement
         *    @returns null
         */
        XMLList.prototype.Put = function (PropertyName, Value,isChildElement)
        {
            isChildElement = isChildElement !== undefined ? isChildElement : false;
            var i = parseInt(PropertyName), r, y, l, z, parent, c, j = 0, q, t;

            if (i+"" == PropertyName)
            {
                r = ResolveValue.call(this._TargetObject);
                /* Firefox doesn't do this
                 if (r == null)
                 {
                 return null;
                 }
                 */
                if (i >= this._Children.length)
                {
                    if (r instanceof XMLList)
                    {
                        if (r.length() != 1)
                        {
                            return null;
                        }

                        r = r[0];
                    }

                    /* Firefox doesn't do this
                     if (r._Class != "element")
                     {
                     return null;
                     }
                     */
                    y = new XML();
                    y._Parent = r;
                    y._Name = this._TargetProperty;
                    y._Attributes = {};

                    if (this._TargetProperty instanceof AttributeName)
                    {
                        if (!!r && Get.call(r, y._Name).length() > 0)
                        {
                            return null;
                        }

                        y._Class = "attribute";
                    }
                    else if (!isChildElement && (this._TargetProperty == null || this._TargetProperty.localName === "*"))
                    {
                        y._Name = null;
                        y._Class = "text";
                    }
                    else
                    {
                        y._Class = "element";
                    }

                    if (y._Class != "attribute")
                    {
                        if (r)
                        {
                            j = 0;

                            if (i > 0)
                            {
                                while (j < r._Children.length-1 && r[j] !== this[i-1])
                                {
                                    ++j;
                                }
                            }
                            else
                            {
                                j = r._Children.length - 1;
                            }

                            Insert.call(r, j+1, y);
                        }

                        if (Value instanceof XMLList)
                        {
                            y._Name = Value._TargetProperty;
                        }
                        else if (Value instanceof XML)
                        {
                            y._Name = Value._Name;
                        }
                    }

                    this.Append(y);
                }

                if (!(Value instanceof XML) || Value._Class === "text" || Value._Class === "attribute")
                {
                    Value = ToString(Value);
                }

                if (this[i]._Class === "attribute")
                {
                    z = ToAttributeName(this[i]._Name);
                    this[i]._Parent.Put(z, Value);
                    this[i] = this[i]._Parent.attribute(z)[0];
                }
                else if (Value instanceof XMLList)
                {
                    //shallow copy?
                    c = Value;
                    parent = this[i]._Parent;

                    if (parent)
                    {
                        q = this[i].childIndex();
                        Replace.call(parent, q, c);
                        for (j = 0, l = c._Children.length; j < l; ++j)
                        {
                            c._Children[j] = c[j] = parent._Children[q+j];
                        }
                    }

                    if (c._Children.length === 0)
                    {
                        for (j = i + 1, l = this._Children.length; j < l; ++j)
                        {
                            this._Children[j-1] = this[j-1] = this[j]
                        }
                    }
                    else
                    {
                        for (j = this._Children.length; j > i; --j)
                        {
                            z = ToString(j + c._Children.length - 1);
                            this._Children[z] = this[z] = this[j];
                        }
                    }

                    for (j = 0, l = c._Children.length; j < l; ++j)
                    {
                        this._Children[i+j] = this[i+j] = c[j];
                    }

                }
                else if (Value instanceof XML || (",text,comment,processing-instruction").indexOf("," + this[i]._Class+",") > -1)
                {
                    parent = !!this[i] && this[i]._Parent;

                    if(parent)
                    {
                        q = this[i].childIndex();
                        Replace.call(parent, q, Value);
                        Value = parent._Children[q];
                    }

                    if (toString.call(Value) === "[object String]")
                    {
                        t = ToXML(Value);
                        t._Parent = this;
                        this._Children[i] = this[i] = t;
                    }
                    else
                    {

                    }
                }
                else
                {
                    this.Append(XMLList(Value));
                }
            }
            /* Firefox doesn't do this
             else if (this.length() <= 1)
             {
             if (this.length() === 0)
             {
             r = ResolveValueList.call(this);

             if (r == null || r.length() != 1)
             {
             return null;
             }

             this.Append(r);
             }
             else
             {
             this[0].Put(PropertyName, Value);
             }
             }*/

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @returns null
         */
        XMLList.prototype.Delete = function (PropertyName)
        {
            var i = parseInt(PropertyName), parent, q, l;

            if (i+"" == PropertyName)
            {
                if (i >= this._Children.length)
                {
                    return true;
                }

                parent = this[i]._Parent;

                if (parent)
                {
                    if (this[i]._Class = "attribute")
                    {
                        parent.Delete(ToAttributeName(this[i]._Name));
                    }
                    else
                    {
                        DeleteByIndex.call(parent, this[i].childIndex());
                    }
                }

                try{
                    this._Children.splice(PropertyName,1);
                    delete this[PropertyName];
                }catch(e){}

                for (q = i + 1, l = this._Children.length; q < l; ++q)
                {
                    this._Children[q-1] = this[q-1] = this[q];
                }
                return true;
            }
            /* Firefox won't do this
             for (q = 0, l = this._Children.length; q < l; ++q)
             {
             if (this[q]._Class === "element")
             {
             this[q].Delete(PropertyName);
             }
             }
             */
            return true;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns null
         */
        XMLList.prototype.Append = function (Value)
        {
            if (!(Value instanceof XML))
            {
                return null;
            }

            var i = this._Children.length, n = 1, j = 0;

            if (Value instanceof XMLList)
            {
                n = Value._Children.length;

                if (n == 0)
                {
                    return null;
                }

                this._TargetObject = Value._TargetObject;
                this._TargetProperty = Value._TargetProperty;

                for (;j < n; ++j)
                {
                    this._Children[i+j] = this[i+j] = Value[j];
                }
            }
            else
            {
                this._Children[i] = this[i] = Value;
            }

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns Boolean
         */
        XMLList.prototype.Equals = function (Value)
        {
            if (Value == undefined && this._Children.length === 0)
            {
                return true;
            }
            else if (Value instanceof XMLList && Value._Children.length === this._Children.length)
            {
                for (var i = 0, l = this._Children.length; i < l; ++i)
                {
                    if (!this[i].Equals(Value[i]))
                    {
                        return false;
                    }
                }
            }
            else if (this._Children.length === 1)
            {
                return this[0].Equals(Value);
            }

            return false;
        };

        /**
         *
         *
         *
         *    @access private
         *    @returns XMLList
         */
        function ResolveValueList ()
        {
            if (this._Children.length > 0)
            {
                return this;
            }

            if (this._TargetObject == null
                || this._TargetProperty == null
                || this._TargetProperty instanceof AttributeName
                || this._TargetProperty.localName === "*"
                )
            {
                return null;
            }

            var base = ResolveValue.call(this._TargetObject), target;

            if (base == null)
            {
                return null;
            }

            target = Get.call(base, this._TargetProperty);

            if (target._Children.length === 0)
            {
                if (base instanceof XMLList && base._Children.length > 1)
                {
                    return null;
                }

                base.Put(this._TargetProperty, "");

                target = Get.call(base, this._TargetProperty);
            }

            return target;
        };

        /**
         *
         *
         *    @param String | Namespace | QName prefix
         *    @param String uri
         *    @returns Namespace
         *    @throws TypeError
         */
        function Namespace (prefix, uri)
        {
            if (!(this instanceof Namespace))
            {
                return prefix && prefix instanceof Namespace
                    ? prefix
                    : new Namespace(prefix, uri);
            }

            if (uri === undefined && prefix === undefined)
            {
                this.prefix = "";
                this.uri = "";
            }
            else if (uri === undefined)
            {
                uri = prefix;
                prefix = undefined;

                if (uri instanceof Namespace)
                {
                    this.prefix = uri.prefix;
                    this.uri = uri.uri;
                }
                else if (uri instanceof QName && uri.uri !== null)
                {
                    this.uri = uri.uri;
                }
                else
                {
                    this.uri = ToString(uri);

                    if (this.uri == "")
                    {
                        this.prefix = "";
                    }
                }
            }
            else
            {
                if (uri instanceof QName)
                {
                    this.uri = uri.uri;
                }
                else
                {
                    this.uri = ToString(uri);
                }

                if (this.uri === "")
                {
                    if (prefix === undefined || ToString(prefix) === "")
                    {
                        this.prefix = "";
                    }
                    else
                    {
                        throw new TypeError("cannot define the prefix for an empty uri");
                    }
                }
                else if (prefix === undefined)
                {
                    this.prefix = undefined;
                }
                else
                {
                    this.prefix = ToString(prefix);
                }
            }
        }

        /**
         *
         *
         *    @var String
         */
        Namespace.prototype.prefix = undefined;

        /**
         *
         *
         *    @var String
         */
        Namespace.prototype.uri = undefined;

        /**
         *
         *
         *    @returns String
         */
        Namespace.prototype.toString = function ()
        {
            return this.uri;
        };

        /**
         *
         *
         *    @param Namespace | String | QName NameSpace
         *    @param String
         *    @returns QName
         */
        function QName (NameSpace, Name)
        {
            if (!(this instanceof QName))
            {
                return NameSpace instanceof QName
                    ? NameSpace
                    : new QName(NameSpace, Name);
            }

            if (Name === undefined)
            {
                Name = NameSpace;
                NameSpace = undefined;
            }

            if (Namespace instanceof QName)
            {
                if (Name === undefined)
                {
                    Name = Name.localName;
                }
            }

            Name = Name === undefined || Name === null
                ? ""
                : ToString(Name);

            if (NameSpace === undefined)
            {
                NameSpace = Name === "*" ? null : GetDefaultNamespace();
            }

            this.localName = Name;

            if (NameSpace == null)
            {
                this.uri = null;
            }
            else
            {
                NameSpace = Namespace(NameSpace);
                this.uri = NameSpace.uri;
                this._Prefix = NameSpace.prefix;
            }
        }

        /**
         *
         *
         *    @var String
         */
        QName.prototype.localName = undefined;

        /**
         *
         *
         *    @var String
         */
        QName.prototype.uri = undefined;

        /**
         *
         *
         *    @param Object InScopeNamespaces
         *    @returns Namespace
         *    @throws TypeError
         */
        function GetNamespace (q, InScopeNamespaces)
        {
            if(!q)
                 return new Namespace();
            if (q.uri === null)
            {
                throw new TypeError();
            }

            InScopeNamespaces = InScopeNamespaces || {};

            var ns, p;

            for (p in InScopeNamespaces)
            {
                if (q.uri === InScopeNamespaces[p].uri)
                {
                    ns = InScopeNamespaces[p];

                    if (!!q._Prefix && q._Prefix === ns.prefix)
                    {
                        return ns;
                    }
                }
            }

            if (!ns)
            {
                ns = !!q._Prefix
                    ? new Namespace(q._Prefix, q.uri)
                    : new Namespace(q.uri);
            }

            return ns;
        };

        /**
         *
         *
         *    @returns String
         */
        QName.prototype.toString = function ()
        {
            return !!this.uri
                ? this.uri + "::" + this.localName
                : this.localName;
        };

        /**
         *
         *
         *    @param AttributeName | QName | String name
         *    @returns AttributeName
         */
        function AttributeName (name)
        {
            if (!(this instanceof AttributeName))
            {
                return name && (name instanceof AttributeName || name instanceof QName)
                    ? name
                    : new AttributeName(name);
            }

            this._Name = name instanceof QName
                ? name
                : new QName(new Namespace(GetDefaultNamespace()||undefined), name);
        }

        /**
         *
         *
         *    @var String
         */
        AttributeName.prototype.localName = undefined;

        /**
         *
         *
         *    @var String
         */
        AttributeName.prototype.uri = undefined;

        /**
         *
         *
         *    @returns String
         */
        AttributeName.prototype.toString = function ()
        {
            return "@" + (!!this._Name.uri
                ? this._Name.uri + "::" + this._Name.localName
                : this._Name.localName
                );
        };

        /**
         *
         *
         *
         */
        function AnyName ()
        {

        }

        /**
         *
         *
         *    @param mixed value
         *    @returns Boolean
         */
        function isXMLName (value)
        {
            if (value instanceof AttributeName)
            {
                return true;
            }

            try{
                var q = QName(value);
            }
            catch (e)
            {
                return false;
            }

            return !!q.localName && (!!q.localName.match(/^[\w\-]+$/i) || !!q.localName.match(/^[\w\-\:]+$/i));
        }

        /**
         *
         *
         *    @param mixed value
         *    @returns String
         *    @throws TypeError
         */
        function ToString (value)
        {
            var i = 0, l, s;

            if (value instanceof XMLList)
            {
                if (value.hasSimpleContent())
                {
                    s = "";

                    for (l = value.length(); i < l; ++i)
                    {
                        if (value[i]._Class != "comment" && value[i]._Class != "processing-instruction")
                        {
                            s += ToString(value[i]);
                        }
                    }

                    return s;
                }

                return ToXMLString(value);
            }
            else if (value instanceof XML)
            {
                if (value._Class === "attribute" || value._Class === "text")
                {
                    return value._Value;
                }

                if (value.hasSimpleContent())
                {
                    s = "";

                    for (l = value.length(); i < l; ++i)
                    {
                        if (value.child(i)._Class != "comment" && value.child(i)._Class != "processing-instruction")
                        {
                            s += ToString(value.child(i));
                        }
                    }

                    return s;
                }

                return ToXMLString(value);
            }
            else if (value instanceof AttributeName)
            {
                return "@" + ToString(value._Name);
            }

            return value === null || value === undefined
                ? ""
                : "" + value;
        }

        /**
         *
         *
         *    @param XML input
         *    @param Object AncestorNamespaces
         *    @param Number IndentLevel
         *    @returns String
         */
        function ToXMLString (input, AncestorNamespaces, IndentLevel)
        {
            var s = "", p = 0, temp, temp2, namespace, namespaceUnion,
                namespaceDeclarations = {}, attrAndNamespaces, prefixes, defaultSet;

            AncestorNamespaces = AncestorNamespaces || {};

            IndentLevel = Number(IndentLevel || 0);

            if (input instanceof XMLList)
            {
                temp = input.hasSimpleContent();

                temp2 = input.length();

                for (; p < temp2; ++p)
                {
                    if (p > 0)
                    {
                        s += "\r\n";
                    }

                    s += ToXMLString(input[p], AncestorNamespaces);
                }

                return s;
            }
            else if (input instanceof XML)
            {
                if (XML.prettyPrinting)
                {
                    //s += new Array(IndentLevel+1).join(" ");
                    for (; p < IndentLevel; ++p)
                    {
                        s += " ";
                    }
                }

                switch (input._Class)
                {
                    case "text":
                        return s + EscapeElementValue(XML.prettyPrinting ? trim(input._Value) : input._Value);

                    case "attribute":
                        return s + EscapeAttributeValue(input._Value);

                    case "comment":
                        return s + "<!--" + input._Value + "-->";

                    case "processing-instruction":
                        return s + "<?" + input._Name.localName + " " + input._Value + "?>";

                    default:
                        namespaceUnion = extend({}, AncestorNamespaces);

                        for (p in input._InScopeNamespaces)
                        {
                            temp = input._InScopeNamespaces[p];

                            if (!AncestorNamespaces[(temp.prefix||"")] || AncestorNamespaces[(temp.prefix||"")].uri != temp.uri)
                            {
                                namespaceUnion[(temp.prefix||"")] = namespaceDeclarations[(temp.prefix||"")] = new Namespace(temp);
                            }
                        }

                        if (!input._Parent)
                        {
                            namespaceUnion[(input._DefaultNamespace.prefix||"")] =
                                namespaceDeclarations[(input._DefaultNamespace.prefix||"")] = new Namespace(input._DefaultNamespace);
                        }
                        /*
                         //firefox doesn't do this
                         for (p in input._Attributes)
                         {
                         namespace = GetNamespace(input._Attributes[p]._Name, namespaceUnion);

                         if (namespace.prefix === undefined)
                         {
                         do {
                         namespace.prefix = !namespaceUnion[""] ? "" : newPrefix();
                         }
                         while(!!namespaceUnion[namespace.prefix]);
                         }

                         namespaceUnion[namespace.prefix] = namespaceDeclarations[namespace.prefix] = namespace;
                         }
                         */

                        s += "<";

                        namespace = GetNamespace(input._Name, namespaceDeclarations);

                        if (namespace.prefix)
                        {
                            s += namespace.prefix + ":";
                        }

                        s += input._Name ? input._Name.localName : "";

                        attrAndNamespaces = extend({}, input._Attributes, namespaceDeclarations);

                        defaultSet = false;

                        for (p in attrAndNamespaces)
                        {
                            s += " ";

                            if (attrAndNamespaces[p] instanceof XML)
                            {
                                temp = GetNamespace(attrAndNamespaces[p]._Name, AncestorNamespaces);

                                if (temp.prefix === undefined && !namespaceUnion[""])
                                {
                                    do{
                                        temp.prefix = !namespaceUnion[""] ? "" : newPrefix();
                                    }
                                    while(namespaceUnion[temp.prefix]);

                                    namespaceUnion[temp.prefix] = namespaceDeclarations[temp.prefix] = new Namespace(temp);
                                }

                                if (temp.prefix)
                                {
                                    s += temp.prefix + ":";
                                }

                                s += attrAndNamespaces[p].localName() + '="' + EscapeAttributeValue(attrAndNamespaces[p]._Value) + '"';
                            }
                            else
                            {
                                s += "xmlns";

                                if (!attrAndNamespaces[p].prefix && defaultSet)
                                {
                                    do{
                                        attrAndNamespaces[p].prefix = newPrefix();
                                    }
                                    while(!!namespaceUnion[attrAndNamespaces[p].prefix]);

                                    namespaceUnion[attrAndNamespaces[p].prefix] =
                                        namespaceDeclarations[attrAndNamespaces[p].prefix] =
                                            new Namespace(attrAndNamespaces[p]);

                                    s += ":" + attrAndNamespaces[p].prefix;
                                }
                                else if (!attrAndNamespaces[p].prefix && !defaultSet)
                                {
                                    defaultSet = true;
                                }
                                else if (attrAndNamespaces[p].prefix)
                                {
                                    s += ":" + attrAndNamespaces[p].prefix;
                                }

                                s += '="' + EscapeAttributeValue(attrAndNamespaces[p].uri) + '"';
                            }
                        }

                        temp = input._Children.length;

                        if (!temp)
                        {
                            return s + "/>";
                        }

                        s += ">";

                        temp2 = temp > 1 || (temp == 1 && input._Class !== "text");

                        names = (!!XML.prettyPrinting && !!temp2) ? IndentLevel + Number(XML.prettyIndent) : 0;

                        prefixes = !!XML.prettyPrinting && !!temp2;

                        for (p = 0; p < temp; ++p)
                        {
                            if (prefixes)
                            {
                                s += "\r\n";
                            }

                            if (input._Children[p])
                            {
                                s += ToXMLString(input._Children[p], namespaceDeclarations, names);
                            }
                        }

                        if (prefixes)
                        {
                            s += "\r\n";

                            for (p = 0; p < IndentLevel; ++p)
                            {
                                s += " ";
                            }
                        }

                        return s + "</" + (namespace.prefix ? namespace.prefix + ":" : "") + input._Name.localName + ">";
                }

                throw new TypeError();
            }
            else if (input === undefined || input === null)
            {
                throw new TypeError();
            }
            else if (toString.call(input) === "[object Object]")
            {
                return EscapeElementValue( input.valueOf().toString() );
            }

            return ToString(input);
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XML
         *    @throws SyntaxError | TypeError
         */
        function ToXML (s)
        {
            var x, div;

            if (s instanceof XMLList)
            {
                if (s.length() == 1)
                {
                    return s[0];
                }
            }
            else if (s instanceof XML)
            {
                return s;
            }
            else if ((",string,number,boolean,").indexOf("," + typeof(s)+",") > -1)
            {

                div = parse('<parent xmlns="' + GetDefaultNamespace() + '">' + s + '</parent>');

                x = ToXML(div.documentElement)

                if (x)
                {
                    if (x.length() == 0)
                    {
                        return new XML();
                    }
                    else if (x.length() == 1)
                    {
                        x.child(0)._Parent = null;
                        return x.child(0);
                    }
                }


                throw new SyntaxError("Failed to convert DOM object to XML");
            }
            else if (s.nodeType && !isNaN(s.nodeType))
            {
                return MapInfoItemToXML(s);
            }

            throw new TypeError();
        }

        /**
         *
         *
         *    @param DOMNode i
         *    @returns XML
         *    @throws TypeError
         */
        function MapInfoItemToXML (i,n)
        {
            var x = new XML(), temp, temp2, temp3, isNScheck = isNSDef, j, l, xmlChild;

            x._Parent = null;

            switch (i.nodeType)
            {
                case TEXT_NODE:
                case CDATA_SECTION_NODE:
                    x._Class = "text";
                    x._Value = "";
                    temp = i;

                    while (temp && (temp.nodeType === TEXT_NODE || temp.nodeType === CDATA_SECTION_NODE))
                    {
                        x._Value += temp.textContent || temp.text || temp.data;
                        temp = temp.nextSibling;
                        if (n && (n.n || n.n == 0))
                        {
                            ++n.n;
                        }
                    }


                    if (XML.ignoreWhitespace && !x._Value.match(/\S+/))
                    {
                        return null;
                    }

                    return x;

                    break;
                case COMMENT_NODE:
                    if (XML.ignoreComments)
                    {
                        return null;
                    }

                    x._Class = "comment";
                    x._Value = i.data || i.textContent || i.text || "";

                    return x;

                    break;
                case PROCESSING_INSTRUCTION_NODE:
                    if (XML.ignoreProcessingInstructions)
                    {
                        return null;
                    }

                    x._Class = "processing-instruction";
                    x._Name = new QName("", i.target);
                    x._Value = i.data || i.textContent || i.text || "";

                    return x;

                    break;
                case ATTRIBUTE_NODE:
                    x._Class = "attribute";

                    temp = i.nodeName.match(/(([\w\-]+):)?([\w\-]+)/);

                    if ( temp[1] )
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace(temp[2]);
                        }
                        else
                        {
                            temp3 = n;//hack for ie -- stupid ie

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == ("xmlns:" + temp[2]))
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }
                        x._DefaultNamespace = new Namespace( temp[2], temp2 );
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }
                    else
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace("");
                        }
                        else
                        {
                            temp3 = i.parentNode;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == "xmlns")
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }

                        x._DefaultNamespace = new Namespace("", temp2);
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }

                    x._Value = i.value || null;

                    return x;

                    break;
                case ELEMENT_NODE:
                    x._Class = "element";
                    temp = i.nodeName.match(/(([\w\-]+):)?([\w\-]+)/);

                    if ( temp[1] )
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace(temp[2]);
                        }
                        else
                        {
                            temp3 = i;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == ("xmlns:" + temp[2]))
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }
                        x._DefaultNamespace = new Namespace( temp[2], temp2 );
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }
                    else
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace("");
                        }
                        else
                        {
                            temp3 = i;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == "xmlns")
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }

                        x._DefaultNamespace = new Namespace("", temp2);

                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }

                    for (temp = 0, temp2 = i.attributes.length; temp < temp2; ++temp)
                    {
                        if (temp3 = isNScheck.exec(i.attributes[temp].nodeName))
                        {
                            x._InScopeNamespaces[temp3[1]] = new Namespace(temp3[1], i.attributes[temp].value);
                        }
                        else if (i.attributes[temp].nodeName === "xmlns")
                        {
                            x._InScopeNamespaces[""] = new Namespace(i.attributes[temp].value);
                        }
                        else
                        {
                            x._Attributes[i.attributes[temp].nodeName] = MapInfoItemToXML(i.attributes[temp], i);
                        }
                    }

                    j = 0;
                    xmlChild = 0;
                    temp = i.childNodes.length;

                    while (j < temp)
                    {
                        n = {n:-1};
                        if (temp3 = MapInfoItemToXML(i.childNodes[j], n))
                        {
                            //even though it is not written this way in the spec
                            //this is how it works in Firefox
                            x._Children[xmlChild] = temp3;
                            x._Children[xmlChild]._Parent = x;

                            if (temp3._Class === "text" && n.n > 0)
                            {
                                j = j + n.n;
                            }

                            ++xmlChild;
                        }

                        ++j;
                    }

                    x._Value = i.textContent || i.text || i.data || "";

                    x._Length = xmlChild;

                    return x;

                    break;
                case DOCUMENT_NODE:
                //firefox won't do this
                //return MapInfoItemToXML(document.documentElement);
                //break;
                case ENTITY_REFERENCE_NODE:
                    throw new TypeError();
                    break;
                default:
                    return null;
                    break;
            }
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XML
         *    @throws TypeError
         */
        function ToXMLList (s)
        {
            var e,x,list,i,l;

            if (s instanceof XMLList)
            {
                return s;
            }
            else if (s instanceof XML)
            {
                list = new XMLList();
                list._Children[0] = list[0] = s;
                list._TargetObject = x._Parent;
                list._TargetProperty = x._Name;

                return list;
            }
            else if ((",string,boolean,number,").indexOf("," + typeof(s)+",") === -1)
            {
                throw new TypeError();
            }

            e = parse('<parent xmlns="' + GetDefaultNamespace() + '">' + s + '</parent>');
            x = ToXML(e.documentElement);
            list = new XMLList();
            i = 0;
            l = x._Children.length;

            list._TargetObject = null;

            for (;i < l; ++i)
            {
                x._Children[i]._Parent = null;
                list._Children[i] = list[i] = x._Children[i];
            }


            return list;
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XMLList
         *    @throws TypeError
         */
        function ToAttributeName (s)
        {
            if (s === "*")
            {
                return new AttributeName(new QName(null, "*"));
            }
            else if (s instanceof QName)
            {
                return new AttributeName(s);
            }
            else if (s instanceof AttributeName)
            {
                return s;
            }

            switch (typeof(s))
            {
                case "undefined":
                case "null":
                case "boolean":
                case "number":
                    throw new TypeError();
                    break;
                case "string":
                    return new AttributeName(new QName(null, (s + "").replace(/^@/,"")));
                    break;
                case "object":
                    return new AttributeName(new QName(null, ToString(s)));
                    break;
            }
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns QName | AttributeName
         *    @throws TypeError
         */
        function ToXMLName (s)
        {
            if (s instanceof QName || s instanceof AttributeName)
            {
                return s;
            }
            else if (s === "*")
            {
                return new QName("*");
            }

            switch (typeof(s))
            {
                case "undefined":
                case "null":
                case "boolean":
                case "number":
                    throw new TypeError();
                    break;
                case "string":
                    if (s.charAt(0) === "@")
                    {
                        return ToAttributeName( s.substr(0) );
                    }

                    return new QName(s);

                    break;
                case "object":
                    return ToXMLName( ToString(s) );
                    break;
            }
        }

        /**
         *
         *
         *    @returns String
         */
        function GetDefaultNamespace ()
        {
            return !!defaultNamespace && defaultNamespace.uri || "";
        }

        /**
         *
         *
         *    @param String s
         *    @returns String
         */
        function EscapeElementValue (s)
        {
            return ((s||"")+"").replace(/./g, function (c)
            {
                switch (c)
                {
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    default:
                        return c;
                }
            });
        }

        /**
         *
         *
         *
         *    @param String s
         *    @returns String
         */
        function EscapeAttributeValue (s)
        {
            return ((s||"")+"").replace(/./g, function (c)
            {
                switch (c)
                {
                    case '"':
                        return "&quot;";
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    case "\r":
                        return "&#xA;";
                    case "\n":
                        return "&#xD;";
                    case "\t":
                        return "&#x9;";
                    default:
                        return c;
                }
            });
        }

        /**
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function Get (PropertyName)
        {
            if (this instanceof XMLList)
            {
                return GetList.call(this, PropertyName);
            }

            if (parseInt(PropertyName)+"" == PropertyName)
            {
                return GetList.call(ToXMLList(this), PropertyName );
            }

            var n = ToXMLName(PropertyName),
                list = new XMLList(), p, l;

            list._TargetObject = this;
            list._TargetProperty = n;

            if (n instanceof AttributeName)
            {
                for (p in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[p]._Name.localName)
                            &&
                            (n._Name.uri == null || n._Name.uri === this._Attributes[p]._Name.uri)
                        )
                    {
                        list.Append(this._Attributes[p]);
                    }
                }
            }
            else
            {
                for (p = 0, l = this._Children.length; p < l; ++p)
                {
                    if (
                        (n.localName === "*" || (this._Children[p]._Class === "element" && this._Children[p]._Name.localName === n.localName))
                            &&
                            (n.uri == null || (this._Children[p]._Class === "element" && n.uri === this._Children[p]._Name.uri))
                        )
                    {
                        list.Append(this._Children[p]);
                    }
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName P
         *    @returns Boolean
         */
        function HasProperty (P)
        {
            if (this instanceof XMLList)
            {
                return HasPropertyList.call(this, P);
            }

            if (parseInt(P) == P)
            {
                return P == "0";
            }

            var n = ToXMLName(P), k, l;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (
                            n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName
                            ) &&
                            (
                                n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri
                                )
                        )
                    {
                        return true;
                    }
                }

                return false;
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName === n.localName))
                        &&
                        (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                    )
                {
                    return true;
                }
            }

            return false;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns Boolean
         *    @throws TypeError
         */
        function DeleteByIndex (PropertyName)
        {
            var i = parseInt(PropertyName);//, q = i + 1, l = this._Children.length;

            if (i == PropertyName)
            {
                if (!!this._Children[i])
                {
                    this._Children[i]._Parent = null;

                    this._Children[i] = null;

                    this._Children.splice(i, 1);

                    /*
                     for (;q < l;++q)
                     {
                     this._Children[q-1] = this._Children[q];
                     }
                     */
                }

                return true;
            }

            throw new TypeError();
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XML
         */
        function DeepCopy ()
        {
            if (this instanceof XMLList)
            {
                return DeepCopyList.call(this);
            }

            var y = new XML(), i, l;//, c, t;

            y._Class = this._Class;
            y._Name = this._Name;
            y._DefaultNamespace = this._DefaultNamespace ? new Namespace(this._DefaultNamespace) : null;
            y._Value = this._Value;
            y._Parent = null;

            for (i in this._InScopeNamespaces)
            {
                y._InScopeNamespaces[i] = new Namespace(this._InScopeNamespaces.prefix, this._InScopeNamespaces.uri);
            }

            for (l in this._Attributes)
            {
                //y._Attributes[i] = arguments.callee.call(this._Attributes[i]);
                //not part of the spec
                y._Attributes[i] = this._Attributes[l].copy();
                y._Attributes[i]._Parent = y;
            }

            for (i = 0, l = this._Children.length; i < l; ++i)
            {
                y._Children[i] = this._Children[i].copy();
                y._Children[i]._Parent = y;
            }

            return y;
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XML
         */
        function ResolveValue ()
        {
            if (this instanceof XMLList)
            {
                return ResolveValueList.call(this);
            }
            return this instanceof XML ? this : null;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function Descendants (PropertyName)
        {
            if (this instanceof XMLList)
            {
                return DescendantsList.call(this, PropertyName);
            }

            var n = ToXMLName(PropertyName),
                list = new XMLList(),
                k, l, dq;

            list._TargetObject = null;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName)
                            &&
                            (n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri)
                        )
                    {
                        list.Append(this._Attributes[k]);
                    }
                }
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName === n.localName))
                        &&
                        (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                    )
                {
                    list.Append(this._Children[k]);
                }

                dq = this._Children[k].descendants(n);

                if (dq.length() > 0)
                {
                    list.Append(dq);
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML Value
         *    @returns null
         *    @throws TypeError | Error
         */
        function Insert (PropertyName, Value)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            var i = parseInt(PropertyName), n, j;

            if (i+"" != PropertyName)
            {
                throw new TypeError("'" + i + "' != '" + PropertyName + "'");
            }

            if (Value === this || indexOf("," + this, Value.descendants("*")) > -1)
            {
                throw new Error();
            }

            n = Value.length();

            for (j = this._Children.length - 1; j >= i; --j)
            {
                this._Children[ j + n ] = this._Children[j];
            }


            if (Value instanceof XMLList)
            {
                for (j = 0; j < n; ++j)
                {
                    Value[j]._Parent = this;
                    this._Children[i + j] = Value[j];
                }
            }
            else
            {
                Replace.call(this, i, Value);
            }

            return null;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML Value
         *    @returns null
         *    @throws TypeError
         */
        function Replace (PropertyName, Value)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var i = parseInt(PropertyName), t;

            if (i+"" != PropertyName)
            {
                throw new TypeError("'" + i + "' != '" + PropertyName + "'");
            }

            if (i >= this._Children.length)
            {
                PropertyName = this._Children.length;
            }

            if (Value instanceof XMLList)
            {
                DeleteByIndex.call(this, PropertyName);
                Insert.call(this, PropertyName, Value);
            }
            else if (Value instanceof XML
                && Value._Class === "element"
                && (",element,comment,processing-instruction,text").indexOf("," + Value._Class + ",") > -1
                )
            {
                Value._Parent = this;

                if (this._Children[PropertyName])
                {
                    this._Children[PropertyName]._Parent = null;
                }

                this._Children[PropertyName] = Value;
            }
            else
            {
                t = new XML();
                t._Parent = this;
                t._Value = ToString(Value);

                if (this._Children[PropertyName])
                {
                    this._Children[PropertyName]._Parent = null;
                }

                this._Children[PropertyName] = t;
            }
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Namespace NameSpace
         *    @returns null
         */
        function AddInScopeNamespace (NameSpace)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var match = null, p;

            if (NameSpace.prefix == "" && this._Name.uri == "")
            {
                return null;
            }

            for (p in this._InScopeNamespaces)
            {
                if (NameSpace.prefix === this._InScopeNamespaces[p].prefix)
                {
                    match = this._InScopeNamespaces[p];
                }
            }

            if (match && match.uri != NameSpace.uri)
            {
                this._InScopeNamespaces[match.prefix] = null;
                try{
                    delete this._InScopeNamespaces[match.prefix];
                }catch(e){}
            }

            this._InScopeNamespaces[NameSpace.prefix] = NameSpace;

            if (this._Name.prefix === NameSpace.prefix)
            {
                this._Name.prefix = undefined;
            }

            for (p in this._Attributes)
            {
                if (this._Attributes[p]._Name.prefix = NameSpace.prefix)
                {
                    this._Attributes[p]._Name.prefix = undefined;
                }
            }

            //do this in order to ensure namespace integrity
            /*match = parse(this.toXMLString());
             this._Node = !!this._Node.parentNode
             ? this._Node.parentNode.replaceChild(match.documentElement, this._Node)
             : match;*/
        }

        /**
         *
         *
         *    @access private
         *    @param String | Number name
         *    @returns Boolean
         */
        function HasPropertyList (name)
        {
            if (ToString( parseInt(name) ) === name)
            {
                return parseInt(name) < this._Children.length;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this[i]._Class === "element" && this[i].hasOwnProperty(name))
                {
                    return true;
                }
            }

            return false;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @returns XMLList
         */
        function GetList (PropertyName)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                return this[PropertyName];
            }

            var list = new XMLList(), i = 0, l = this._Children.length, temp;
            list._TargetObject = this;
            list._TargetProperty = PropertyName;

            for (;i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    temp = Get.call(this._Children[i], PropertyName);

                    if (temp._Children.length > 0)
                    {
                        list.Append(temp);
                    }
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XMLList
         */
        function DeepCopyList ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;

            list._TargetObject = this._TargetObject;
            list._TargetProperty = this._TargetProperty;
            list._Class = this._Class;
            list._Value = this._Value;

            for (;i < l; ++i)
            {
                list.Append(DeepCopy.call(this[i]));
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function DescendantsList (PropertyName)
        {
            var list = new XMLList(), i = 0, l = this._Children.length, temp;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    if ((temp = Descendants.call(this[i], "*")) && temp.length() > 0)
                    {
                        list.Append(temp);
                    }
                }
            }

            return list;
        }

        /**
         *    http://blog.stevenlevithan.com/archives/faster-trim-javascript
         *
         *
         *    @param String s
         *    @returns String
         */
        function trim (str)
        {
            if(!str)
                return str;
            var    str = str.replace(/^\s\s*/, ""),
                ws = /\s/,
                i = str.length;
            while (ws.test(str.charAt(--i)));
            return str.slice(0, i + 1);
        }

        /**
         *    Generates a prefix for a QName that is not already
         *    a property of the optional argument
         *
         *    @param Object prefixes
         *    @returns String
         */
        function newPrefix (prefixes)
        {
            prefixes = prefixes || {};

            var num = Math.random()
                .toString()
                .substr(2)
                .replace(/.{2}/g, function (a)
                {
                    a = Number(a);
                    return (a > 90 ? 90 : (a < 65 ? 65 : a)) + "";
                });

            num = String.fromCharCode(
                Number(num.substr(0, 2)) & 0xFF,
                Number(num.substr(2, 2)) & 0xFF,
                Number(num.substr(4, 2)) & 0xFF,
                Number(num.substr(6, 2)) & 0xFF,
                Number(num.substr(8, 2)) & 0xFF,
                Number(num.substr(10, 2)) & 0xFF
            ).toLowerCase();

            while (num in prefixes)
            {
                num = arguments.callee(prefixes);
            }

            return num;
        }

        /**
         *
         *
         *    @param String str
         *    @returns DOMNode
         *    @throws SyntaxError
         */
        function parse (str)
        {
            var xmlDoc, success = true;

            if (isActiveXSupported("Microsoft.XMLDOM")) //Internet Explorer
            {
                try{
                    xmlDoc                      = new ActiveXObject("Microsoft.XMLDOM");
                    xmlDoc.async                = 'false';
                    xmlDoc.preserveWhiteSpace   = true;
                    xmlDoc.resolveExternals     = false;
                    xmlDoc.validateOnParse         = false;
                    xmlDoc.setProperty('ProhibitDTD', false);
                    success = xmlDoc.loadXML(str);
                }catch(e){}
            }
            else
            {
                try{//Firefox, Mozilla, Opera, etc.
                    xmlDoc = new DOMParser();
                    xmlDoc = xmlDoc.parseFromString(str, "text/xml");
                }catch(e){}
            }

            if (!success || !xmlDoc || xmlDoc.documentElement.nodeName == "parsererror")
            {
                throw new SyntaxError(!!xmlDoc && xmlDoc.documentElement.childNodes[0].nodeValue);
            }

            return xmlDoc;
        }

        /**
         *
         *
         *    @param Object obj
         *    @returns Number
         */
        function count (obj)
        {
            if ("__count__" in obj)
            {
                return obj.__count__;
            }

            var i = 0, k;

            for (k in obj)
            {
                if (obj.hasOwnProperty(k))
                {
                    ++i;
                }
            }

            return i;
        }

        /**
         *
         *
         *    @param Object obj
         *    @param XMLList list
         *    @returns Number
         */
        function indexOf (obj, list)
        {
            for (var i = 0, l = list.length(); i < l; ++i)
            {
                if (list[i].Equals(obj))
                {
                    return i;
                }
            }

            return -1;
        }

        /**
         *
         *
         *    @param mixed obj
         *    @param mixed ...
         *    @returns mixed
         */
        function extend (obj)
        {
            for (var p, i = 1, l = arguments.length; i < l; ++i)
            {
                for (p in arguments[i])
                {
                    obj[p] = arguments[i][p];
                }
            }

            return obj;
        }

        /**
         *
         *
         *
         */
        function createDocumentFrom (xml)
        {
            return parse(xml.length() == 1 ? xml.toXMLString() : "<x>" + xml.toXMLString() + "</x>");
        }

        /**
         *
         *
         *
         */
        function xmlToDomNode (xml)
        {
            switch (xml.nodeKind())
            {
                case "element":
                    return createDocumentFrom(xml).documentElement;

                case "text":
                    return xmlDoc.createTextNode(xml.toString());

                case "comment":
                    return xmlDoc.createComment(xml.toString().slice(4, -3));

                case "processing-instruction":
                    return xmlDoc.createProcessingInstruction(
                        xml.localName(),
                        xml.toString().slice(2, -2).replace(piName, "")
                    );

                case "attribute":
                    return createAttributeNS(xml);
            }
            return null;
        }

        function adoptNode (doc, node)
        {
            if (!!doc.adoptNode)
            {
                return doc.adoptNode(node);
            }

            var b = doc.documentElement || doc.body;
            return b.removeChild(b.appendChild(node));
        }

        function evaluate (doc, expr, xml)
        {
            var res, l, n = "";

            if (!!doc.evaluate)
            {
                res = doc.evaluate(
                    expr,
                    doc,
                    doc.createNSResolver(doc),
                    XPathResult.ORDERED_NODE_ITERATOR_TYPE,
                    null
                );

                l = [];

                while(n = res.iterateNext())
                {
                    l[l.length] = n;
                }

                return l;
            }

            if ("setProperty" in doc){

                res = allNamespaces(xml);

                if (count(res))
                {
                    for (l in res)
                    {
                        n += " xmlns:" + l + '="' + EscapeAttributeValue(res[l]) + '"';
                    }

                    doc.setProperty('SelectionNamespaces', n.substr(1));
                }

                doc.setProperty("SelectionLanguage", "XPath");
            }

            return isActiveXSupported("Microsoft.XMLDOM") && doc.selectNodes(expr);
        }

        function isActiveXSupported(type) {
            try {
                new ActiveXObject(type);
                return true;
            } catch (e) {
                return false;
            }
        }

        function allNamespaces (xml, un)
        {
            var ns = un || {},
                i = 0,
                c = xml.children(),
                l = c.length(),
                n = un == undefined
                    ? inscope(xml)
                    : xml._InScopeNamespaces,
                p;

            for (;i < l; ++i)
            {
                ns = arguments.callee(c[i], ns);
            }

            for (p in n)
            {
                if (n[p].prefix)
                {
                    ns[n[p].prefix] = n[p].uri;
                }
            }

            return ns;
        }

        function inscope (xml)
        {
            var ns = {},
                i = 0,
                n = xml.inScopeNamespaces(),
                l = n.length;

            for (;i < l; ++i)
            {
                if (n[i].prefix)
                {
                    ns[n[i].prefix] = n[i].uri;
                }
            }

            return ns;
        }

        function createAttributeNS (xml)
        {
            var ns = xml.namespace(),
                node = !!xmlDoc.createAttributeNS
                    ? xmlDoc.createAttributeNS(ns.uri, xml.localName())
                    : xmlDoc.createAttribute((ns.prefix ? ns.prefix + ":" : "" ) + xml.localName());

            node.nodeValue = xml.toString();
            return node;
        }

        function transform (xml, style, params)
        {
            var xsl, res, i = 0, l = (params||[]).length;

            if (!window.XSLTProcessor)
            {
                //TODO: Need to create a way to set parameters on an IE stylesheet
                //XSLProcessor
                //http://msdn.microsoft.com/en-us/library/ms757015%28v=VS.85%29.aspx
                //http://msdn.microsoft.com/en-us/library/ms763679%28VS.85%29.aspx
                //http://msdn.microsoft.com/en-us/library/ms754594%28v=VS.85%29.aspx

                res = createDocumentFrom(xml).transformNode(createDocumentFrom(style));

                return !!res && ToXML(res) || null;
            }

            xsl = new XSLTProcessor();

            xsl.importStyleSheet(createDocumentFrom(style));

            for (; i < l; ++i)
            {
                res = params[i];
                xsl.setParameter(res.namespaceURI, res.localName, res.value);
            }

            res = xsl.transformToDocument(createDocumentFrom(doc))

            return !!res && ToXML(res) || null;
        }

        for (p in XML.prototype)
        {
            defaultXMLPrototype += p + ",";
        }

        for (p in XMLList.prototype)
        {
            defaultXMLListPrototype += p + ",";
        }

        /**
         *
         *
         *
         */
        window.XML              = XML;
        window.XMLList          = XMLList;
        window.QName            = QName;
        window.Namespace        = Namespace;
        window.isXMLName        = isXMLName;
        window.AttributeName    = AttributeName;

    })();
}
(function(){var h=this;
function aa(a){var b=typeof a;if("object"==b)if(a){if(a instanceof Array)return"array";if(a instanceof Object)return b;var c=Object.prototype.toString.call(a);if("[object Window]"==c)return"object";if("[object Array]"==c||"number"==typeof a.length&&"undefined"!=typeof a.splice&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("splice"))return"array";if("[object Function]"==c||"undefined"!=typeof a.call&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("call"))return"function"}else return"null";else if("function"==
b&&"undefined"==typeof a.call)return"object";return b}function k(a){return"string"==typeof a}function ba(a,b,c){return a.call.apply(a.bind,arguments)}function ca(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var c=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(c,d);return a.apply(b,c)}}return function(){return a.apply(b,arguments)}}
function da(a,b,c){da=Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?ba:ca;return da.apply(null,arguments)}function ea(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var b=c.slice();b.push.apply(b,arguments);return a.apply(this,b)}}
function m(a){var b=n;function c(){}c.prototype=b.prototype;a.u=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.t=function(a,c,f){return b.prototype[c].apply(a,Array.prototype.slice.call(arguments,2))}};var fa=String.prototype.trim?function(a){return a.trim()}:function(a){return a.replace(/^[\s\xa0]+|[\s\xa0]+$/g,"")};function ga(a,b){return a<b?-1:a>b?1:0};var q;a:{var ha=h.navigator;if(ha){var ia=ha.userAgent;if(ia){q=ia;break a}}q=""}function r(a){return-1!=q.indexOf(a)};var s=Array.prototype,ja=s.indexOf?function(a,b,c){return s.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if(k(a))return k(b)&&1==b.length?a.indexOf(b,c):-1;for(;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1},t=s.forEach?function(a,b,c){s.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=k(a)?a.split(""):a,f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)},ka=s.filter?function(a,b,c){return s.filter.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=[],f=0,g=k(a)?
a.split(""):a,l=0;l<d;l++)if(l in g){var p=g[l];b.call(c,p,l,a)&&(e[f++]=p)}return e},u=s.reduce?function(a,b,c,d){d&&(b=da(b,d));return s.reduce.call(a,b,c)}:function(a,b,c,d){var e=c;t(a,function(c,g){e=b.call(d,e,c,g,a)});return e},la=s.some?function(a,b,c){return s.some.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=k(a)?a.split(""):a,f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return!0;return!1};
function ma(a,b){var c;a:{c=a.length;for(var d=k(a)?a.split(""):a,e=0;e<c;e++)if(e in d&&b.call(void 0,d[e],e,a)){c=e;break a}c=-1}return 0>c?null:k(a)?a.charAt(c):a[c]}function na(a){return s.concat.apply(s,arguments)}function oa(a,b,c){return 2>=arguments.length?s.slice.call(a,b):s.slice.call(a,b,c)};var pa=r("Opera")||r("OPR"),v=r("Trident")||r("MSIE"),qa=r("Gecko")&&-1==q.toLowerCase().indexOf("webkit")&&!(r("Trident")||r("MSIE")),ra=-1!=q.toLowerCase().indexOf("webkit");function sa(){var a=h.document;return a?a.documentMode:void 0}
var ta=function(){var a="",b;if(pa&&h.opera)return a=h.opera.version,"function"==aa(a)?a():a;qa?b=/rv\:([^\);]+)(\)|;)/:v?b=/\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/:ra&&(b=/WebKit\/(\S+)/);b&&(a=(a=b.exec(q))?a[1]:"");return v&&(b=sa(),b>parseFloat(a))?String(b):a}(),ua={};
function va(a){if(!ua[a]){for(var b=0,c=fa(String(ta)).split("."),d=fa(String(a)).split("."),e=Math.max(c.length,d.length),f=0;0==b&&f<e;f++){var g=c[f]||"",l=d[f]||"",p=RegExp("(\\d*)(\\D*)","g"),x=RegExp("(\\d*)(\\D*)","g");do{var C=p.exec(g)||["","",""],X=x.exec(l)||["","",""];if(0==C[0].length&&0==X[0].length)break;b=ga(0==C[1].length?0:parseInt(C[1],10),0==X[1].length?0:parseInt(X[1],10))||ga(0==C[2].length,0==X[2].length)||ga(C[2],X[2])}while(0==b)}ua[a]=0<=b}}
var wa=h.document,xa=wa&&v?sa()||("CSS1Compat"==wa.compatMode?parseInt(ta,10):5):void 0;!qa&&!v||v&&v&&9<=xa||qa&&va("1.9.1");v&&va("9");function ya(a,b){if(a.contains&&1==b.nodeType)return a==b||a.contains(b);if("undefined"!=typeof a.compareDocumentPosition)return a==b||Boolean(a.compareDocumentPosition(b)&16);for(;b&&a!=b;)b=b.parentNode;return b==a}
function za(a,b){if(a==b)return 0;if(a.compareDocumentPosition)return a.compareDocumentPosition(b)&2?1:-1;if(v&&!(v&&9<=xa)){if(9==a.nodeType)return-1;if(9==b.nodeType)return 1}if("sourceIndex"in a||a.parentNode&&"sourceIndex"in a.parentNode){var c=1==a.nodeType,d=1==b.nodeType;if(c&&d)return a.sourceIndex-b.sourceIndex;var e=a.parentNode,f=b.parentNode;return e==f?Aa(a,b):!c&&ya(e,b)?-1*Ba(a,b):!d&&ya(f,a)?Ba(b,a):(c?a.sourceIndex:e.sourceIndex)-(d?b.sourceIndex:f.sourceIndex)}d=9==a.nodeType?a:
a.ownerDocument||a.document;c=d.createRange();c.selectNode(a);c.collapse(!0);d=d.createRange();d.selectNode(b);d.collapse(!0);return c.compareBoundaryPoints(h.Range.START_TO_END,d)}function Ba(a,b){var c=a.parentNode;if(c==b)return-1;for(var d=b;d.parentNode!=c;)d=d.parentNode;return Aa(d,a)}function Aa(a,b){for(var c=b;c=c.previousSibling;)if(c==a)return-1;return 1};function w(a,b,c){this.a=a;this.b=b||1;this.d=c||1};function Ca(a){this.b=a;this.a=0}function Da(a){a=a.match(Ea);for(var b=0;b<a.length;b++)Fa.test(a[b])&&a.splice(b,1);return new Ca(a)}var Ea=RegExp("\\$?(?:(?![0-9-])[\\w-]+:)?(?![0-9-])[\\w-]+|\\/\\/|\\.\\.|::|\\d+(?:\\.\\d*)?|\\.\\d+|\"[^\"]*\"|'[^']*'|[!<>]=|\\s+|.","g"),Fa=/^\s/;function y(a,b){return a.b[a.a+(b||0)]}function z(a){return a.b[a.a++]}function Ga(a){return a.b.length<=a.a};function A(a,b){this.h=a.toLowerCase();this.c=b?b.toLowerCase():"http://www.w3.org/1999/xhtml"}A.prototype.a=function(a){var b=a.nodeType;return 1!=b&&2!=b?!1:"*"!=this.h&&this.h!=a.nodeName.toLowerCase()?!1:this.c==(a.namespaceURI?a.namespaceURI.toLowerCase():"http://www.w3.org/1999/xhtml")};A.prototype.d=function(){return this.h};A.prototype.toString=function(){return"Name Test: "+("http://www.w3.org/1999/xhtml"==this.c?"":this.c+":")+this.h};function B(a,b){this.f=a;this.c=void 0!==b?b:null;this.b=null;switch(a){case "comment":this.b=8;break;case "text":this.b=3;break;case "processing-instruction":this.b=7;break;case "node":break;default:throw Error("Unexpected argument");}}function Ha(a){return"comment"==a||"text"==a||"processing-instruction"==a||"node"==a}B.prototype.a=function(a){return null===this.b||this.b==a.nodeType};B.prototype.d=function(){return this.f};
B.prototype.toString=function(){var a="Kind Test: "+this.f;null===this.c||(a+=D(this.c));return a};function Ia(a){switch(a.nodeType){case 1:return ea(Ja,a);case 9:return Ia(a.documentElement);case 11:case 10:case 6:case 12:return Ka;default:return a.parentNode?Ia(a.parentNode):Ka}}function Ka(){return null}function Ja(a,b){if(a.prefix==b)return a.namespaceURI||"http://www.w3.org/1999/xhtml";var c=a.getAttributeNode("xmlns:"+b);return c&&c.specified?c.value||null:a.parentNode&&9!=a.parentNode.nodeType?Ja(a.parentNode,b):null};var E=v&&!(v&&9<=xa),La=v&&!(v&&8<=xa);function F(a,b,c,d){this.a=a;this.nodeName=c;this.nodeValue=d;this.nodeType=2;this.parentNode=this.ownerElement=b}function Ma(a,b){var c=La&&"href"==b.nodeName?a.getAttribute(b.nodeName,2):b.nodeValue;return new F(b,a,b.nodeName,c)};function G(a){var b=null,c=a.nodeType;1==c&&(b=a.textContent,b=void 0==b||null==b?a.innerText:b,b=void 0==b||null==b?"":b);if("string"!=typeof b)if(E&&"title"==a.nodeName.toLowerCase()&&1==c)b=a.text;else if(9==c||1==c){a=9==c?a.documentElement:a.firstChild;for(var c=0,d=[],b="";a;){do 1!=a.nodeType&&(b+=a.nodeValue),E&&"title"==a.nodeName.toLowerCase()&&(b+=a.text),d[c++]=a;while(a=a.firstChild);for(;c&&!(a=d[--c].nextSibling););}}else b=a.nodeValue;return""+b}
function H(a,b,c){if(null===b)return!0;try{if(!a.getAttribute)return!1}catch(d){return!1}La&&"class"==b&&(b="className");return null==c?!!a.getAttribute(b):a.getAttribute(b,2)==c}function I(a,b,c,d,e){return(E?Na:Oa).call(null,a,b,k(c)?c:null,k(d)?d:null,e||new J)}
function Na(a,b,c,d,e){if(a instanceof A||8==a.b||c&&null===a.b){var f=b.all;if(!f)return e;a=Pa(a);if("*"!=a&&(f=b.getElementsByTagName(a),!f))return e;if(c){for(var g=[],l=0;b=f[l++];)H(b,c,d)&&g.push(b);f=g}for(l=0;b=f[l++];)"*"==a&&"!"==b.tagName||K(e,b);return e}Qa(a,b,c,d,e);return e}
function Oa(a,b,c,d,e){b.getElementsByName&&d&&"name"==c&&!v?(b=b.getElementsByName(d),t(b,function(b){a.a(b)&&K(e,b)})):b.getElementsByClassName&&d&&"class"==c?(b=b.getElementsByClassName(d),t(b,function(b){b.className==d&&a.a(b)&&K(e,b)})):a instanceof B?Qa(a,b,c,d,e):b.getElementsByTagName&&(b=b.getElementsByTagName(a.d()),t(b,function(a){H(a,c,d)&&K(e,a)}));return e}
function Ra(a,b,c,d,e){var f;if((a instanceof A||8==a.b||c&&null===a.b)&&(f=b.childNodes)){var g=Pa(a);if("*"!=g&&(f=ka(f,function(a){return a.tagName&&a.tagName.toLowerCase()==g}),!f))return e;c&&(f=ka(f,function(a){return H(a,c,d)}));t(f,function(a){"*"==g&&("!"==a.tagName||"*"==g&&1!=a.nodeType)||K(e,a)});return e}return Sa(a,b,c,d,e)}function Sa(a,b,c,d,e){for(b=b.firstChild;b;b=b.nextSibling)H(b,c,d)&&a.a(b)&&K(e,b);return e}
function Qa(a,b,c,d,e){for(b=b.firstChild;b;b=b.nextSibling)H(b,c,d)&&a.a(b)&&K(e,b),Qa(a,b,c,d,e)}function Pa(a){if(a instanceof B){if(8==a.b)return"!";if(null===a.b)return"*"}return a.d()};function J(){this.b=this.a=null;this.i=0}function Ta(a){this.d=a;this.a=this.b=null}function Ua(a,b){if(!a.a)return b;if(!b.a)return a;for(var c=a.a,d=b.a,e=null,f=null,g=0;c&&d;){var f=c.d,l=d.d;f==l||f instanceof F&&l instanceof F&&f.a==l.a?(f=c,c=c.a,d=d.a):0<za(c.d,d.d)?(f=d,d=d.a):(f=c,c=c.a);(f.b=e)?e.a=f:a.a=f;e=f;g++}for(f=c||d;f;)f.b=e,e=e.a=f,g++,f=f.a;a.b=e;a.i=g;return a}function Va(a,b){var c=new Ta(b);c.a=a.a;a.b?a.a.b=c:a.a=a.b=c;a.a=c;a.i++}
function K(a,b){var c=new Ta(b);c.b=a.b;a.a?a.b.a=c:a.a=a.b=c;a.b=c;a.i++}function Wa(a){return(a=a.a)?a.d:null}function Xa(a){return(a=Wa(a))?G(a):""}function L(a,b){return new Ya(a,!!b)}function Ya(a,b){this.d=a;this.b=(this.c=b)?a.b:a.a;this.a=null}function M(a){var b=a.b;if(null==b)return null;var c=a.a=b;a.b=a.c?b.b:b.a;return c.d};function n(a){this.g=a;this.b=this.e=!1;this.d=null}function D(a){return"\n  "+a.toString().split("\n").join("\n  ")}function Za(a,b){a.e=b}function $a(a,b){a.b=b}function N(a,b){var c=a.a(b);return c instanceof J?+Xa(c):+c}function O(a,b){var c=a.a(b);return c instanceof J?Xa(c):""+c}function P(a,b){var c=a.a(b);return c instanceof J?!!c.i:!!c};function Q(a,b,c){n.call(this,a.g);this.c=a;this.f=b;this.k=c;this.e=b.e||c.e;this.b=b.b||c.b;this.c==ab&&(c.b||c.e||4==c.g||0==c.g||!b.d?b.b||b.e||4==b.g||0==b.g||!c.d||(this.d={name:c.d.name,l:b}):this.d={name:b.d.name,l:c})}m(Q);
function R(a,b,c,d,e){b=b.a(d);c=c.a(d);var f;if(b instanceof J&&c instanceof J){e=L(b);for(d=M(e);d;d=M(e))for(b=L(c),f=M(b);f;f=M(b))if(a(G(d),G(f)))return!0;return!1}if(b instanceof J||c instanceof J){b instanceof J?e=b:(e=c,c=b);e=L(e);b=typeof c;for(d=M(e);d;d=M(e)){switch(b){case "number":d=+G(d);break;case "boolean":d=!!G(d);break;case "string":d=G(d);break;default:throw Error("Illegal primitive type for comparison.");}if(a(d,c))return!0}return!1}return e?"boolean"==typeof b||"boolean"==typeof c?
a(!!b,!!c):"number"==typeof b||"number"==typeof c?a(+b,+c):a(b,c):a(+b,+c)}Q.prototype.a=function(a){return this.c.j(this.f,this.k,a)};Q.prototype.toString=function(){var a="Binary Expression: "+this.c,a=a+D(this.f);return a+=D(this.k)};function bb(a,b,c,d){this.a=a;this.p=b;this.g=c;this.j=d}bb.prototype.toString=function(){return this.a};var cb={};function S(a,b,c,d){if(cb.hasOwnProperty(a))throw Error("Binary operator already created: "+a);a=new bb(a,b,c,d);return cb[a.toString()]=a}
S("div",6,1,function(a,b,c){return N(a,c)/N(b,c)});S("mod",6,1,function(a,b,c){return N(a,c)%N(b,c)});S("*",6,1,function(a,b,c){return N(a,c)*N(b,c)});S("+",5,1,function(a,b,c){return N(a,c)+N(b,c)});S("-",5,1,function(a,b,c){return N(a,c)-N(b,c)});S("<",4,2,function(a,b,c){return R(function(a,b){return a<b},a,b,c)});S(">",4,2,function(a,b,c){return R(function(a,b){return a>b},a,b,c)});S("<=",4,2,function(a,b,c){return R(function(a,b){return a<=b},a,b,c)});
S(">=",4,2,function(a,b,c){return R(function(a,b){return a>=b},a,b,c)});var ab=S("=",3,2,function(a,b,c){return R(function(a,b){return a==b},a,b,c,!0)});S("!=",3,2,function(a,b,c){return R(function(a,b){return a!=b},a,b,c,!0)});S("and",2,2,function(a,b,c){return P(a,c)&&P(b,c)});S("or",1,2,function(a,b,c){return P(a,c)||P(b,c)});function db(a,b){if(b.a.length&&4!=a.g)throw Error("Primary expression must evaluate to nodeset if filter has predicate(s).");n.call(this,a.g);this.c=a;this.f=b;this.e=a.e;this.b=a.b}m(db);db.prototype.a=function(a){a=this.c.a(a);return eb(this.f,a)};db.prototype.toString=function(){var a;a="Filter:"+D(this.c);return a+=D(this.f)};function fb(a,b){if(b.length<a.o)throw Error("Function "+a.h+" expects at least"+a.o+" arguments, "+b.length+" given");if(null!==a.n&&b.length>a.n)throw Error("Function "+a.h+" expects at most "+a.n+" arguments, "+b.length+" given");a.s&&t(b,function(b,d){if(4!=b.g)throw Error("Argument "+d+" to function "+a.h+" is not of type Nodeset: "+b);});n.call(this,a.g);this.f=a;this.c=b;Za(this,a.e||la(b,function(a){return a.e}));$a(this,a.r&&!b.length||a.q&&!!b.length||la(b,function(a){return a.b}))}m(fb);
fb.prototype.a=function(a){return this.f.j.apply(null,na(a,this.c))};fb.prototype.toString=function(){var a="Function: "+this.f;if(this.c.length)var b=u(this.c,function(a,b){return a+D(b)},"Arguments:"),a=a+D(b);return a};function gb(a,b,c,d,e,f,g,l,p){this.h=a;this.g=b;this.e=c;this.r=d;this.q=e;this.j=f;this.o=g;this.n=void 0!==l?l:g;this.s=!!p}gb.prototype.toString=function(){return this.h};var hb={};
function T(a,b,c,d,e,f,g,l){if(hb.hasOwnProperty(a))throw Error("Function already created: "+a+".");hb[a]=new gb(a,b,c,d,!1,e,f,g,l)}T("boolean",2,!1,!1,function(a,b){return P(b,a)},1);T("ceiling",1,!1,!1,function(a,b){return Math.ceil(N(b,a))},1);T("concat",3,!1,!1,function(a,b){return u(oa(arguments,1),function(b,d){return b+O(d,a)},"")},2,null);T("contains",2,!1,!1,function(a,b,c){b=O(b,a);a=O(c,a);return-1!=b.indexOf(a)},2);T("count",1,!1,!1,function(a,b){return b.a(a).i},1,1,!0);
T("false",2,!1,!1,function(){return!1},0);T("floor",1,!1,!1,function(a,b){return Math.floor(N(b,a))},1);T("id",4,!1,!1,function(a,b){function c(a){if(E){var b=e.all[a];if(b){if(b.nodeType&&a==b.id)return b;if(b.length)return ma(b,function(b){return a==b.id})}return null}return e.getElementById(a)}var d=a.a,e=9==d.nodeType?d:d.ownerDocument,d=O(b,a).split(/\s+/),f=[];t(d,function(a){a=c(a);!a||0<=ja(f,a)||f.push(a)});f.sort(za);var g=new J;t(f,function(a){K(g,a)});return g},1);
T("lang",2,!1,!1,function(){return!1},1);T("last",1,!0,!1,function(a){if(1!=arguments.length)throw Error("Function last expects ()");return a.d},0);T("local-name",3,!1,!0,function(a,b){var c=b?Wa(b.a(a)):a.a;return c?c.localName||c.nodeName.toLowerCase():""},0,1,!0);T("name",3,!1,!0,function(a,b){var c=b?Wa(b.a(a)):a.a;return c?c.nodeName.toLowerCase():""},0,1,!0);T("namespace-uri",3,!0,!1,function(){return""},0,1,!0);
T("normalize-space",3,!1,!0,function(a,b){return(b?O(b,a):G(a.a)).replace(/[\s\xa0]+/g," ").replace(/^\s+|\s+$/g,"")},0,1);T("not",2,!1,!1,function(a,b){return!P(b,a)},1);T("number",1,!1,!0,function(a,b){return b?N(b,a):+G(a.a)},0,1);T("position",1,!0,!1,function(a){return a.b},0);T("round",1,!1,!1,function(a,b){return Math.round(N(b,a))},1);T("starts-with",2,!1,!1,function(a,b,c){b=O(b,a);a=O(c,a);return 0==b.lastIndexOf(a,0)},2);T("string",3,!1,!0,function(a,b){return b?O(b,a):G(a.a)},0,1);
T("string-length",1,!1,!0,function(a,b){return(b?O(b,a):G(a.a)).length},0,1);T("substring",3,!1,!1,function(a,b,c,d){c=N(c,a);if(isNaN(c)||Infinity==c||-Infinity==c)return"";d=d?N(d,a):Infinity;if(isNaN(d)||-Infinity===d)return"";c=Math.round(c)-1;var e=Math.max(c,0);a=O(b,a);if(Infinity==d)return a.substring(e);b=Math.round(d);return a.substring(e,c+b)},2,3);T("substring-after",3,!1,!1,function(a,b,c){b=O(b,a);a=O(c,a);c=b.indexOf(a);return-1==c?"":b.substring(c+a.length)},2);
T("substring-before",3,!1,!1,function(a,b,c){b=O(b,a);a=O(c,a);a=b.indexOf(a);return-1==a?"":b.substring(0,a)},2);T("sum",1,!1,!1,function(a,b){for(var c=L(b.a(a)),d=0,e=M(c);e;e=M(c))d+=+G(e);return d},1,1,!0);T("translate",3,!1,!1,function(a,b,c,d){b=O(b,a);c=O(c,a);var e=O(d,a);a=[];for(d=0;d<c.length;d++){var f=c.charAt(d);f in a||(a[f]=e.charAt(d))}c="";for(d=0;d<b.length;d++)f=b.charAt(d),c+=f in a?a[f]:f;return c},3);T("true",2,!1,!1,function(){return!0},0);function ib(a){n.call(this,3);this.c=a.substring(1,a.length-1)}m(ib);ib.prototype.a=function(){return this.c};ib.prototype.toString=function(){return"Literal: "+this.c};function jb(a){n.call(this,1);this.c=a}m(jb);jb.prototype.a=function(){return this.c};jb.prototype.toString=function(){return"Number: "+this.c};function kb(a,b){n.call(this,a.g);this.f=a;this.c=b;this.e=a.e;this.b=a.b;if(1==this.c.length){var c=this.c[0];c.m||c.c!=lb||(c=c.k,"*"!=c.d()&&(this.d={name:c.d(),l:null}))}}m(kb);function U(){n.call(this,4)}m(U);U.prototype.a=function(a){var b=new J;a=a.a;9==a.nodeType?K(b,a):K(b,a.ownerDocument);return b};U.prototype.toString=function(){return"Root Helper Expression"};function mb(){n.call(this,4)}m(mb);mb.prototype.a=function(a){var b=new J;K(b,a.a);return b};mb.prototype.toString=function(){return"Context Helper Expression"};
function nb(a){return"/"==a||"//"==a}kb.prototype.a=function(a){var b=this.f.a(a);if(!(b instanceof J))throw Error("Filter expression must evaluate to nodeset.");a=this.c;for(var c=0,d=a.length;c<d&&b.i;c++){var e=a[c],f=L(b,e.c.a),g;if(e.e||e.c!=ob)if(e.e||e.c!=pb)for(g=M(f),b=e.a(new w(g));null!=(g=M(f));)g=e.a(new w(g)),b=Ua(b,g);else g=M(f),b=e.a(new w(g));else{for(g=M(f);(b=M(f))&&(!g.contains||g.contains(b))&&b.compareDocumentPosition(g)&8;g=b);b=e.a(new w(g))}}return b};
kb.prototype.toString=function(){var a;a="Path Expression:"+D(this.f);if(this.c.length){var b=u(this.c,function(a,b){return a+D(b)},"Steps:");a+=D(b)}return a};function qb(a,b){this.a=a;this.b=!!b}
function eb(a,b,c){for(c=c||0;c<a.a.length;c++)for(var d=a.a[c],e=L(b),f=b.i,g,l=0;g=M(e);l++){var p=a.b?f-l:l+1;g=d.a(new w(g,p,f));if("number"==typeof g)p=p==g;else if("string"==typeof g||"boolean"==typeof g)p=!!g;else if(g instanceof J)p=0<g.i;else throw Error("Predicate.evaluate returned an unexpected type.");if(!p){p=e;g=p.d;var x=p.a;if(!x)throw Error("Next must be called at least once before remove.");var C=x.b,x=x.a;C?C.a=x:g.a=x;x?x.b=C:g.b=C;g.i--;p.a=null}}return b}
qb.prototype.toString=function(){return u(this.a,function(a,b){return a+D(b)},"Predicates:")};function V(a,b,c,d){n.call(this,4);this.c=a;this.k=b;this.f=c||new qb([]);this.m=!!d;b=this.f;b=0<b.a.length?b.a[0].d:null;a.b&&b&&(a=b.name,a=E?a.toLowerCase():a,this.d={name:a,l:b.l});a:{a=this.f;for(b=0;b<a.a.length;b++)if(c=a.a[b],c.e||1==c.g||0==c.g){a=!0;break a}a=!1}this.e=a}m(V);
V.prototype.a=function(a){var b=a.a,c=null,c=this.d,d=null,e=null,f=0;c&&(d=c.name,e=c.l?O(c.l,a):null,f=1);if(this.m)if(this.e||this.c!=rb)if(a=L((new V(sb,new B("node"))).a(a)),b=M(a))for(c=this.j(b,d,e,f);null!=(b=M(a));)c=Ua(c,this.j(b,d,e,f));else c=new J;else c=I(this.k,b,d,e),c=eb(this.f,c,f);else c=this.j(a.a,d,e,f);return c};V.prototype.j=function(a,b,c,d){a=this.c.d(this.k,a,b,c);return a=eb(this.f,a,d)};
V.prototype.toString=function(){var a;a="Step:"+D("Operator: "+(this.m?"//":"/"));this.c.h&&(a+=D("Axis: "+this.c));a+=D(this.k);if(this.f.a.length){var b=u(this.f.a,function(a,b){return a+D(b)},"Predicates:");a+=D(b)}return a};function tb(a,b,c,d){this.h=a;this.d=b;this.a=c;this.b=d}tb.prototype.toString=function(){return this.h};var ub={};function W(a,b,c,d){if(ub.hasOwnProperty(a))throw Error("Axis already created: "+a);b=new tb(a,b,c,!!d);return ub[a]=b}
W("ancestor",function(a,b){for(var c=new J,d=b;d=d.parentNode;)a.a(d)&&Va(c,d);return c},!0);W("ancestor-or-self",function(a,b){var c=new J,d=b;do a.a(d)&&Va(c,d);while(d=d.parentNode);return c},!0);
var lb=W("attribute",function(a,b){var c=new J,d=a.d();if("style"==d&&b.style&&E)return K(c,new F(b.style,b,"style",b.style.cssText)),c;var e=b.attributes;if(e)if(a instanceof B&&null===a.b||"*"==d)for(var d=0,f;f=e[d];d++)E?f.nodeValue&&K(c,Ma(b,f)):K(c,f);else(f=e.getNamedItem(d))&&(E?f.nodeValue&&K(c,Ma(b,f)):K(c,f));return c},!1),rb=W("child",function(a,b,c,d,e){return(E?Ra:Sa).call(null,a,b,k(c)?c:null,k(d)?d:null,e||new J)},!1,!0);W("descendant",I,!1,!0);
var sb=W("descendant-or-self",function(a,b,c,d){var e=new J;H(b,c,d)&&a.a(b)&&K(e,b);return I(a,b,c,d,e)},!1,!0),ob=W("following",function(a,b,c,d){var e=new J;do for(var f=b;f=f.nextSibling;)H(f,c,d)&&a.a(f)&&K(e,f),e=I(a,f,c,d,e);while(b=b.parentNode);return e},!1,!0);W("following-sibling",function(a,b){for(var c=new J,d=b;d=d.nextSibling;)a.a(d)&&K(c,d);return c},!1);W("namespace",function(){return new J},!1);
var vb=W("parent",function(a,b){var c=new J;if(9==b.nodeType)return c;if(2==b.nodeType)return K(c,b.ownerElement),c;var d=b.parentNode;a.a(d)&&K(c,d);return c},!1),pb=W("preceding",function(a,b,c,d){var e=new J,f=[];do f.unshift(b);while(b=b.parentNode);for(var g=1,l=f.length;g<l;g++){var p=[];for(b=f[g];b=b.previousSibling;)p.unshift(b);for(var x=0,C=p.length;x<C;x++)b=p[x],H(b,c,d)&&a.a(b)&&K(e,b),e=I(a,b,c,d,e)}return e},!0,!0);
W("preceding-sibling",function(a,b){for(var c=new J,d=b;d=d.previousSibling;)a.a(d)&&Va(c,d);return c},!0);var wb=W("self",function(a,b){var c=new J;a.a(b)&&K(c,b);return c},!1);function xb(a){n.call(this,1);this.c=a;this.e=a.e;this.b=a.b}m(xb);xb.prototype.a=function(a){return-N(this.c,a)};xb.prototype.toString=function(){return"Unary Expression: -"+D(this.c)};function yb(a){n.call(this,4);this.c=a;Za(this,la(this.c,function(a){return a.e}));$a(this,la(this.c,function(a){return a.b}))}m(yb);yb.prototype.a=function(a){var b=new J;t(this.c,function(c){c=c.a(a);if(!(c instanceof J))throw Error("Path expression must evaluate to NodeSet.");b=Ua(b,c)});return b};yb.prototype.toString=function(){return u(this.c,function(a,b){return a+D(b)},"Union Expression:")};function zb(a,b){this.a=a;this.b=b}function Ab(a){for(var b,c=[];;){Y(a,"Missing right hand side of binary expression.");b=Bb(a);var d=z(a.a);if(!d)break;var e=(d=cb[d]||null)&&d.p;if(!e){a.a.a--;break}for(;c.length&&e<=c[c.length-1].p;)b=new Q(c.pop(),c.pop(),b);c.push(b,d)}for(;c.length;)b=new Q(c.pop(),c.pop(),b);return b}function Y(a,b){if(Ga(a.a))throw Error(b);}function Cb(a,b){var c=z(a.a);if(c!=b)throw Error("Bad token, expected: "+b+" got: "+c);}
function Db(a){a=z(a.a);if(")"!=a)throw Error("Bad token: "+a);}function Eb(a){a=z(a.a);if(2>a.length)throw Error("Unclosed literal string");return new ib(a)}function Fb(a){var b=z(a.a),c=b.indexOf(":");if(-1==c)return new A(b);var d=b.substring(0,c);a=a.b(d);if(!a)throw Error("Namespace prefix not declared: "+d);b=b.substr(c+1);return new A(b,a)}
function Gb(a){var b,c=[],d;if(nb(y(a.a))){b=z(a.a);d=y(a.a);if("/"==b&&(Ga(a.a)||"."!=d&&".."!=d&&"@"!=d&&"*"!=d&&!/(?![0-9])[\w]/.test(d)))return new U;d=new U;Y(a,"Missing next location step.");b=Hb(a,b);c.push(b)}else{a:{b=y(a.a);d=b.charAt(0);switch(d){case "$":throw Error("Variable reference not allowed in HTML XPath");case "(":z(a.a);b=Ab(a);Y(a,'unclosed "("');Cb(a,")");break;case '"':case "'":b=Eb(a);break;default:if(isNaN(+b))if(!Ha(b)&&/(?![0-9])[\w]/.test(d)&&"("==y(a.a,1)){b=z(a.a);b=
hb[b]||null;z(a.a);for(d=[];")"!=y(a.a);){Y(a,"Missing function argument list.");d.push(Ab(a));if(","!=y(a.a))break;z(a.a)}Y(a,"Unclosed function argument list.");Db(a);b=new fb(b,d)}else{b=null;break a}else b=new jb(+z(a.a))}"["==y(a.a)&&(d=new qb(Ib(a)),b=new db(b,d))}if(b)if(nb(y(a.a)))d=b;else return b;else b=Hb(a,"/"),d=new mb,c.push(b)}for(;nb(y(a.a));)b=z(a.a),Y(a,"Missing next location step."),b=Hb(a,b),c.push(b);return new kb(d,c)}
function Hb(a,b){var c,d,e;if("/"!=b&&"//"!=b)throw Error('Step op should be "/" or "//"');if("."==y(a.a))return d=new V(wb,new B("node")),z(a.a),d;if(".."==y(a.a))return d=new V(vb,new B("node")),z(a.a),d;var f;if("@"==y(a.a))f=lb,z(a.a),Y(a,"Missing attribute name");else if("::"==y(a.a,1)){if(!/(?![0-9])[\w]/.test(y(a.a).charAt(0)))throw Error("Bad token: "+z(a.a));c=z(a.a);f=ub[c]||null;if(!f)throw Error("No axis with name: "+c);z(a.a);Y(a,"Missing node name")}else f=rb;c=y(a.a);if(/(?![0-9])[\w]/.test(c.charAt(0)))if("("==
y(a.a,1)){if(!Ha(c))throw Error("Invalid node type: "+c);c=z(a.a);if(!Ha(c))throw Error("Invalid type name: "+c);Cb(a,"(");Y(a,"Bad nodetype");e=y(a.a).charAt(0);var g=null;if('"'==e||"'"==e)g=Eb(a);Y(a,"Bad nodetype");Db(a);c=new B(c,g)}else c=Fb(a);else if("*"==c)c=Fb(a);else throw Error("Bad token: "+z(a.a));e=new qb(Ib(a),f.a);return d||new V(f,c,e,"//"==b)}
function Ib(a){for(var b=[];"["==y(a.a);){z(a.a);Y(a,"Missing predicate expression.");var c=Ab(a);b.push(c);Y(a,"Unclosed predicate expression.");Cb(a,"]")}return b}function Bb(a){if("-"==y(a.a))return z(a.a),new xb(Bb(a));var b=Gb(a);if("|"!=y(a.a))a=b;else{for(b=[b];"|"==z(a.a);)Y(a,"Missing next union location path."),b.push(Gb(a));a.a.a--;a=new yb(b)}return a};function Jb(a,b){if(!a.length)throw Error("Empty XPath expression.");var c=Da(a);if(Ga(c))throw Error("Invalid XPath expression.");b?"function"==aa(b)||(b=da(b.lookupNamespaceURI,b)):b=function(){return null};var d=Ab(new zb(c,b));if(!Ga(c))throw Error("Bad token: "+z(c));this.evaluate=function(a,b){var c=d.a(new w(a));return new Z(c,b)}}
function Z(a,b){if(0==b)if(a instanceof J)b=4;else if("string"==typeof a)b=2;else if("number"==typeof a)b=1;else if("boolean"==typeof a)b=3;else throw Error("Unexpected evaluation result.");if(2!=b&&1!=b&&3!=b&&!(a instanceof J))throw Error("value could not be converted to the specified type");this.resultType=b;var c;switch(b){case 2:this.stringValue=a instanceof J?Xa(a):""+a;break;case 1:this.numberValue=a instanceof J?+Xa(a):+a;break;case 3:this.booleanValue=a instanceof J?0<a.i:!!a;break;case 4:case 5:case 6:case 7:var d=
L(a);c=[];for(var e=M(d);e;e=M(d))c.push(e instanceof F?e.a:e);this.snapshotLength=a.i;this.invalidIteratorState=!1;break;case 8:case 9:d=Wa(a);this.singleNodeValue=d instanceof F?d.a:d;break;default:throw Error("Unknown XPathResult type.");}var f=0;this.iterateNext=function(){if(4!=b&&5!=b)throw Error("iterateNext called with wrong result type");return f>=c.length?null:c[f++]};this.snapshotItem=function(a){if(6!=b&&7!=b)throw Error("snapshotItem called with wrong result type");return a>=c.length||
0>a?null:c[a]}}Z.ANY_TYPE=0;Z.NUMBER_TYPE=1;Z.STRING_TYPE=2;Z.BOOLEAN_TYPE=3;Z.UNORDERED_NODE_ITERATOR_TYPE=4;Z.ORDERED_NODE_ITERATOR_TYPE=5;Z.UNORDERED_NODE_SNAPSHOT_TYPE=6;Z.ORDERED_NODE_SNAPSHOT_TYPE=7;Z.ANY_UNORDERED_NODE_TYPE=8;Z.FIRST_ORDERED_NODE_TYPE=9;function Kb(a){this.lookupNamespaceURI=Ia(a)}
function Lb(a){a=a||h;var b=a.document;b.evaluate||(a.XPathResult=Z,b.evaluate=function(a,b,e,f){return(new Jb(a,e)).evaluate(b,f)},b.createExpression=function(a,b){return new Jb(a,b)},b.createNSResolver=function(a){return new Kb(a)})}var Mb=["wgxpath","install"],$=h;Mb[0]in $||!$.execScript||$.execScript("var "+Mb[0]);for(var Nb;Mb.length&&(Nb=Mb.shift());)Mb.length||void 0===Lb?$[Nb]?$=$[Nb]:$=$[Nb]={}:$[Nb]=Lb;})()

/**
 * @license wysihtml5 v0.4.0pre
 * https://github.com/xing/wysihtml5
 *
 * Author: Christopher Blum (https://github.com/tiff)
 *
 * Copyright (C) 2012 XING AG
 * Licensed under the MIT license (MIT)
 *
 */
var wysihtml5 = {
    version : "0.4.0pre",

    // namespaces
    commands : {},
    dom : {},
    quirks : {},
    toolbar : {},
    lang : {},
    selection : {},
    views : {},

    INVISIBLE_SPACE : "\uFEFF",

    EMPTY_FUNCTION : function () {
    },

    ELEMENT_NODE : 1,
    TEXT_NODE : 3,

    BACKSPACE_KEY : 8,
    ENTER_KEY : 13,
    ESCAPE_KEY : 27,
    SPACE_KEY : 32,
    DELETE_KEY : 46,
    TAB_KEY : 9,
    BLOCK_ELEMENTS_GROUP : ["H1", "H2", "H3", "H4", "H5", "H6", "P"]
};
/**
 * @license Rangy, a cross-browser JavaScript range and selection library
 * http://code.google.com/p/rangy/
 *
 * Copyright 2011, Tim Down
 * Licensed under the MIT license.
 * Version: 1.2.2
 * Build date: 13 November 2011
 */
window.rangy = (function () {

    var OBJECT = "object", FUNCTION = "function", UNDEFINED = "undefined";

    var domRangeProperties = ["startContainer", "startOffset", "endContainer", "endOffset", "collapsed",
        "commonAncestorContainer", "START_TO_START", "START_TO_END", "END_TO_START", "END_TO_END"];

    var domRangeMethods = ["setStart", "setStartBefore", "setStartAfter", "setEnd", "setEndBefore",
        "setEndAfter", "collapse", "selectNode", "selectNodeContents", "compareBoundaryPoints", "deleteContents",
        "extractContents", "cloneContents", "insertNode", "surroundContents", "cloneRange", "toString", "detach"];

    var textRangeProperties = ["boundingHeight", "boundingLeft", "boundingTop", "boundingWidth", "htmlText", "text"];

    // Subset of TextRange's full set of methods that we're interested in
    var textRangeMethods = ["collapse", "compareEndPoints", "duplicate", "getBookmark", "moveToBookmark",
        "moveToElementText", "parentElement", "pasteHTML", "select", "setEndPoint", "getBoundingClientRect"];

    /*----------------------------------------------------------------------------------------------------------------*/

    // Trio of functions taken from Peter Michaux's article:
    // http://peter.michaux.ca/articles/feature-detection-state-of-the-art-browser-scripting
    function isHostMethod(o, p) {
        var t = typeof o[p];
        return t == FUNCTION || (!!(t == OBJECT && o[p])) || t == "unknown";
    }

    function isHostObject(o, p) {
        return !!(typeof o[p] == OBJECT && o[p]);
    }

    function isHostProperty(o, p) {
        return typeof o[p] != UNDEFINED;
    }

    // Creates a convenience function to save verbose repeated calls to tests functions
    function createMultiplePropertyTest(testFunc) {
        return function (o, props) {
            var i = props.length;
            while (i--) {
                if (!testFunc(o, props[i])) {
                    return false;
                }
            }
            return true;
        };
    }

    // Next trio of functions are a convenience to save verbose repeated calls to previous two functions
    var areHostMethods = createMultiplePropertyTest(isHostMethod);
    var areHostObjects = createMultiplePropertyTest(isHostObject);
    var areHostProperties = createMultiplePropertyTest(isHostProperty);

    function isTextRange(range) {
        return range && areHostMethods(range, textRangeMethods) && areHostProperties(range, textRangeProperties);
    }

    var api = {
        version : "1.2.2",
        initialized : false,
        supported : true,

        util : {
            isHostMethod : isHostMethod,
            isHostObject : isHostObject,
            isHostProperty : isHostProperty,
            areHostMethods : areHostMethods,
            areHostObjects : areHostObjects,
            areHostProperties : areHostProperties,
            isTextRange : isTextRange
        },

        features : {},

        modules : {},
        config : {
            alertOnWarn : false,
            preferTextRange : false
        }
    };

    function fail(reason) {
        window.alert("Rangy not supported in your browser. Reason: " + reason);
        api.initialized = true;
        api.supported = false;
    }

    api.fail = fail;

    function warn(msg) {
        var warningMessage = "Rangy warning: " + msg;
        if (api.config.alertOnWarn) {
            window.alert(warningMessage);
        } else if (typeof window.console != UNDEFINED && typeof window.console.log != UNDEFINED) {
            window.console.log(warningMessage);
        }
    }

    api.warn = warn;

    if ({}.hasOwnProperty) {
        api.util.extend = function (o, props) {
            for (var i in props) {
                if (props.hasOwnProperty(i)) {
                    o[i] = props[i];
                }
            }
        };
    } else {
        fail("hasOwnProperty not supported");
    }

    var initListeners = [];
    var moduleInitializers = [];

    // Initialization
    function init() {
        if (api.initialized) {
            return;
        }
        var testRange;
        var implementsDomRange = false, implementsTextRange = false;

        // First, perform basic feature tests

        if (isHostMethod(document, "createRange")) {
            testRange = document.createRange();
            if (areHostMethods(testRange, domRangeMethods) && areHostProperties(testRange, domRangeProperties)) {
                implementsDomRange = true;
            }
            testRange.detach();
        }

        var body = isHostObject(document, "body") ? document.body : document.getElementsByTagName("body")[0];

        /* In case createRange is supported skipping validation for createTextRange API
         * as its not used in such scenario as well as reduces performance(CQ-4228166)  */
        if (!implementsDomRange && body && isHostMethod(body, "createTextRange")) {
            testRange = body.createTextRange();
            if (isTextRange(testRange)) {
                implementsTextRange = true;
            }
        }

        if (!implementsDomRange && !implementsTextRange) {
            fail("Neither Range nor TextRange are implemented");
        }

        api.initialized = true;
        api.features = {
            implementsDomRange : implementsDomRange,
            implementsTextRange : implementsTextRange
        };

        // Initialize modules and call init listeners
        var allListeners = moduleInitializers.concat(initListeners);
        for (var i = 0, len = allListeners.length;
             i < len;
             ++i) {
            try {
                allListeners[i](api);
            } catch (ex) {
                if (isHostObject(window, "console") && isHostMethod(window.console, "log")) {
                    window.console.log("Init listener threw an exception. Continuing.", ex);
                }
            }
        }
    }

    // Allow external scripts to initialize this library in case it's loaded after the document has loaded
    api.init = init;

    // Execute listener immediately if already initialized
    api.addInitListener = function (listener) {
        if (api.initialized) {
            listener(api);
        } else {
            initListeners.push(listener);
        }
    };

    var createMissingNativeApiListeners = [];

    api.addCreateMissingNativeApiListener = function (listener) {
        createMissingNativeApiListeners.push(listener);
    };

    function createMissingNativeApi(win) {
        win = win || window;
        init();

        // Notify listeners
        for (var i = 0, len = createMissingNativeApiListeners.length;
             i < len;
             ++i) {
            createMissingNativeApiListeners[i](win);
        }
    }

    api.createMissingNativeApi = createMissingNativeApi;

    /**
     * @constructor
     */
    function Module(name) {
        this.name = name;
        this.initialized = false;
        this.supported = false;
    }

    Module.prototype.fail = function (reason) {
        this.initialized = true;
        this.supported = false;

        throw new Error("Module '" + this.name + "' failed to load: " + reason);
    };

    Module.prototype.warn = function (msg) {
        api.warn("Module " + this.name + ": " + msg);
    };

    Module.prototype.createError = function (msg) {
        return new Error("Error in Rangy " + this.name + " module: " + msg);
    };

    api.createModule = function (name, initFunc) {
        var module = new Module(name);
        api.modules[name] = module;

        moduleInitializers.push(function (api) {
            initFunc(api, module);
            module.initialized = true;
            module.supported = true;
        });
    };

    api.requireModules = function (modules) {
        for (var i = 0, len = modules.length, module, moduleName;
             i < len;
             ++i) {
            moduleName = modules[i];
            module = api.modules[moduleName];
            if (!module || !(module instanceof Module)) {
                throw new Error("Module '" + moduleName + "' not found");
            }
            if (!module.supported) {
                throw new Error("Module '" + moduleName + "' not supported");
            }
        }
    };

    /*----------------------------------------------------------------------------------------------------------------*/

    // Wait for document to load before running tests

    var docReady = false;

    var loadHandler = function (e) {

        if (!docReady) {
            docReady = true;
            if (!api.initialized) {
                init();
            }
        }
    };

    // Test whether we have window and document objects that we will need
    if (typeof window == UNDEFINED) {
        fail("No window found");
        return;
    }
    if (typeof document == UNDEFINED) {
        fail("No document found");
        return;
    }

    if (isHostMethod(document, "addEventListener")) {
        document.addEventListener("DOMContentLoaded", loadHandler, false);
    }

    // Add a fallback in case the DOMContentLoaded event isn't supported
    if (isHostMethod(window, "addEventListener")) {
        window.addEventListener("load", loadHandler, false);
    } else if (isHostMethod(window, "attachEvent")) {
        window.attachEvent("onload", loadHandler);
    } else {
        fail("Window does not have required addEventListener or attachEvent method");
    }

    return api;
})();
rangy.createModule("DomUtil", function (api, module) {

    var UNDEF = "undefined";
    var util = api.util;

    // Perform feature tests
    if (!util.areHostMethods(document, ["createDocumentFragment", "createElement", "createTextNode"])) {
        module.fail("document missing a Node creation method");
    }

    if (!util.isHostMethod(document, "getElementsByTagName")) {
        module.fail("document missing getElementsByTagName method");
    }

    var el = document.createElement("div");
    if (!util.areHostMethods(el, ["insertBefore", "appendChild", "cloneNode"] || !util.areHostObjects(el, ["previousSibling", "nextSibling", "childNodes", "parentNode"]))) {
        module.fail("Incomplete Element implementation");
    }

    // innerHTML is required for Range's createContextualFragment method
    if (!util.isHostProperty(el, "innerHTML")) {
        module.fail("Element is missing innerHTML property");
    }

    var textNode = document.createTextNode("test");
    if (!util.areHostMethods(textNode, ["splitText", "deleteData", "insertData", "appendData", "cloneNode"] || !util.areHostObjects(el, ["previousSibling", "nextSibling", "childNodes", "parentNode"]) || !util.areHostProperties(textNode, ["data"]))) {
        module.fail("Incomplete Text Node implementation");
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    // Removed use of indexOf because of a bizarre bug in Opera that is thrown in one of the Acid3 tests. I haven't been
    // able to replicate it outside of the test. The bug is that indexOf returns -1 when called on an Array that
    // contains just the document as a single element and the value searched for is the document.
    var arrayContains = /*Array.prototype.indexOf ?
     function(arr, val) {
     return arr.indexOf(val) > -1;
     }:*/

        function (arr, val) {
            var i = arr.length;
            while (i--) {
                if (arr[i] === val) {
                    return true;
                }
            }
            return false;
        };

    // Opera 11 puts HTML elements in the null namespace, it seems, and IE 7 has undefined namespaceURI
    function isHtmlNamespace(node) {
        var ns;
        return typeof node.namespaceURI == UNDEF || ((ns = node.namespaceURI) === null || ns == "http://www.w3.org/1999/xhtml");
    }

    function parentElement(node) {
        var parent = node.parentNode;
        return (parent.nodeType == 1) ? parent : null;
    }

    function getNodeIndex(node) {
        var i = 0;
        while ((node = node.previousSibling)) {
            i++;
        }
        return i;
    }

    function getNodeLength(node) {
        var childNodes;
        return isCharacterDataNode(node) ? node.length : ((childNodes = node.childNodes) ? childNodes.length : 0);
    }

    function getCommonAncestor(node1, node2) {
        var ancestors = [], n;
        for (n = node1;
             n;
             n = n.parentNode) {
            ancestors.push(n);
        }

        for (n = node2;
             n;
             n = n.parentNode) {
            if (arrayContains(ancestors, n)) {
                return n;
            }
        }

        return null;
    }

    function isAncestorOf(ancestor, descendant, selfIsAncestor) {
        var n = selfIsAncestor ? descendant : descendant.parentNode;
        while (n) {
            if (n === ancestor) {
                return true;
            } else {
                n = n.parentNode;
            }
        }
        return false;
    }

    function getClosestAncestorIn(node, ancestor, selfIsAncestor) {
        var p, n = selfIsAncestor ? node : node.parentNode;
        while (n) {
            p = n.parentNode;
            if (p === ancestor) {
                return n;
            }
            n = p;
        }
        return null;
    }

    function isCharacterDataNode(node) {
        var t = node.nodeType;
        return t == 3 || t == 4 || t == 8; // Text, CDataSection or Comment
    }

    function insertAfter(node, precedingNode) {
        var nextNode = precedingNode.nextSibling, parent = precedingNode.parentNode;
        if (nextNode) {
            parent.insertBefore(node, nextNode);
        } else {
            parent.appendChild(node);
        }
        return node;
    }

    // Note that we cannot use splitText() because it is bugridden in IE 9.
    function splitDataNode(node, index) {
        var newNode = node.cloneNode(false);
        newNode.deleteData(0, index);
        node.deleteData(index, node.length - index);
        insertAfter(newNode, node);
        return newNode;
    }

    function getDocument(node) {
        if (node.nodeType == 9) {
            return node;
        } else if (typeof node.ownerDocument != UNDEF) {
            return node.ownerDocument;
        } else if (typeof node.document != UNDEF) {
            return node.document;
        } else if (node.parentNode) {
            return getDocument(node.parentNode);
        } else {
            throw new Error("getDocument: no document found for node");
        }
    }

    function getWindow(node) {
        var doc = getDocument(node);
        if (typeof doc.defaultView != UNDEF) {
            return doc.defaultView;
        } else if (typeof doc.parentWindow != UNDEF) {
            return doc.parentWindow;
        } else {
            throw new Error("Cannot get a window object for node");
        }
    }

    function getIframeDocument(iframeEl) {
        if (typeof iframeEl.contentDocument != UNDEF) {
            return iframeEl.contentDocument;
        } else if (typeof iframeEl.contentWindow != UNDEF) {
            return iframeEl.contentWindow.document;
        } else {
            throw new Error("getIframeWindow: No Document object found for iframe element");
        }
    }

    function getIframeWindow(iframeEl) {
        if (typeof iframeEl.contentWindow != UNDEF) {
            return iframeEl.contentWindow;
        } else if (typeof iframeEl.contentDocument != UNDEF) {
            return iframeEl.contentDocument.defaultView;
        } else {
            throw new Error("getIframeWindow: No Window object found for iframe element");
        }
    }

    function getBody(doc) {
        return util.isHostObject(doc, "body") ? doc.body : doc.getElementsByTagName("body")[0];
    }

    function getRootContainer(node) {
        var parent;
        while ((parent = node.parentNode)) {
            node = parent;
        }
        return node;
    }

    function comparePoints(nodeA, offsetA, nodeB, offsetB) {
        // See http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Comparing
        var nodeC, root, childA, childB, n;
        if (nodeA == nodeB) {

            // Case 1: nodes are the same
            return offsetA === offsetB ? 0 : (offsetA < offsetB) ? -1 : 1;
        } else if ((nodeC = getClosestAncestorIn(nodeB, nodeA, true))) {

            // Case 2: node C (container B or an ancestor) is a child node of A
            return offsetA <= getNodeIndex(nodeC) ? -1 : 1;
        } else if ((nodeC = getClosestAncestorIn(nodeA, nodeB, true))) {

            // Case 3: node C (container A or an ancestor) is a child node of B
            return getNodeIndex(nodeC) < offsetB ? -1 : 1;
        } else {

            // Case 4: containers are siblings or descendants of siblings
            root = getCommonAncestor(nodeA, nodeB);
            childA = (nodeA === root) ? root : getClosestAncestorIn(nodeA, root, true);
            childB = (nodeB === root) ? root : getClosestAncestorIn(nodeB, root, true);

            if (childA === childB) {
                // This shouldn't be possible

                throw new Error("comparePoints got to case 4 and childA and childB are the same!");
            } else {
                n = root.firstChild;
                while (n) {
                    if (n === childA) {
                        return -1;
                    } else if (n === childB) {
                        return 1;
                    }
                    n = n.nextSibling;
                }
                throw new Error("Should not be here!");
            }
        }
    }

    function fragmentFromNodeChildren(node) {
        var fragment = getDocument(node).createDocumentFragment(), child;
        while ((child = node.firstChild)) {
            fragment.appendChild(child);
        }
        return fragment;
    }

    function inspectNode(node) {
        if (!node) {
            return "[No node]";
        }
        if (isCharacterDataNode(node)) {
            return '"' + node.data + '"';
        } else if (node.nodeType == 1) {
            var idAttr = node.id ? ' id="' + node.id + '"' : "";
            return "<" + node.nodeName + idAttr + ">[" + node.childNodes.length + "]";
        } else {
            return node.nodeName;
        }
    }

    /**
     * @constructor
     */
    function NodeIterator(root) {
        this.root = root;
        this._next = root;
    }

    NodeIterator.prototype = {
        _current : null,

        hasNext : function () {
            return !!this._next;
        },

        next : function () {
            var n = this._current = this._next;
            var child, next;
            if (this._current) {
                child = n.firstChild;
                if (child) {
                    this._next = child;
                } else {
                    next = null;
                    while ((n !== this.root) && !(next = n.nextSibling)) {
                        n = n.parentNode;
                    }
                    this._next = next;
                }
            }
            return this._current;
        },

        detach : function () {
            this._current = this._next = this.root = null;
        }
    };

    function createIterator(root) {
        return new NodeIterator(root);
    }

    /**
     * @constructor
     */
    function DomPosition(node, offset) {
        this.node = node;
        this.offset = offset;
    }

    DomPosition.prototype = {
        equals : function (pos) {
            return this.node === pos.node & this.offset == pos.offset;
        },

        inspect : function () {
            return "[DomPosition(" + inspectNode(this.node) + ":" + this.offset + ")]";
        }
    };

    /**
     * @constructor
     */
    function DOMException(codeName) {
        this.code = this[codeName];
        this.codeName = codeName;
        this.message = "DOMException: " + this.codeName;
    }

    DOMException.prototype = {
        INDEX_SIZE_ERR : 1,
        HIERARCHY_REQUEST_ERR : 3,
        WRONG_DOCUMENT_ERR : 4,
        NO_MODIFICATION_ALLOWED_ERR : 7,
        NOT_FOUND_ERR : 8,
        NOT_SUPPORTED_ERR : 9,
        INVALID_STATE_ERR : 11
    };

    DOMException.prototype.toString = function () {
        return this.message;
    };

    api.dom = {
        arrayContains : arrayContains,
        isHtmlNamespace : isHtmlNamespace,
        parentElement : parentElement,
        getNodeIndex : getNodeIndex,
        getNodeLength : getNodeLength,
        getCommonAncestor : getCommonAncestor,
        isAncestorOf : isAncestorOf,
        getClosestAncestorIn : getClosestAncestorIn,
        isCharacterDataNode : isCharacterDataNode,
        insertAfter : insertAfter,
        splitDataNode : splitDataNode,
        getDocument : getDocument,
        getWindow : getWindow,
        getIframeWindow : getIframeWindow,
        getIframeDocument : getIframeDocument,
        getBody : getBody,
        getRootContainer : getRootContainer,
        comparePoints : comparePoints,
        inspectNode : inspectNode,
        fragmentFromNodeChildren : fragmentFromNodeChildren,
        createIterator : createIterator,
        DomPosition : DomPosition
    };

    api.DOMException = DOMException;
});
rangy.createModule("DomRange", function (api, module) {
    api.requireModules(["DomUtil"]);

    var dom = api.dom;
    var DomPosition = dom.DomPosition;
    var DOMException = api.DOMException;

    /*----------------------------------------------------------------------------------------------------------------*/

    // Utility functions

    function isNonTextPartiallySelected(node, range) {
        return (node.nodeType != 3) && (dom.isAncestorOf(node, range.startContainer, true) || dom.isAncestorOf(node, range.endContainer, true));
    }

    function getRangeDocument(range) {
        return dom.getDocument(range.startContainer);
    }

    function dispatchEvent(range, type, args) {
        var listeners = range._listeners[type];
        if (listeners) {
            for (var i = 0, len = listeners.length;
                 i < len;
                 ++i) {
                listeners[i].call(range, {target : range, args : args});
            }
        }
    }

    function getBoundaryBeforeNode(node) {
        return new DomPosition(node.parentNode, dom.getNodeIndex(node));
    }

    function getBoundaryAfterNode(node) {
        return new DomPosition(node.parentNode, dom.getNodeIndex(node) + 1);
    }

    function insertNodeAtPosition(node, n, o) {
        var firstNodeInserted = node.nodeType == 11 ? node.firstChild : node;
        if (dom.isCharacterDataNode(n)) {
            if (o == n.length) {
                dom.insertAfter(node, n);
            } else {
                n.parentNode.insertBefore(node, o == 0 ? n : dom.splitDataNode(n, o));
            }
        } else if (o >= n.childNodes.length) {
            n.appendChild(node);
        } else {
            n.insertBefore(node, n.childNodes[o]);
        }
        return firstNodeInserted;
    }

    function cloneSubtree(iterator) {
        var partiallySelected;
        for (var node, frag = getRangeDocument(iterator.range).createDocumentFragment(), subIterator;
             node = iterator.next();) {
            partiallySelected = iterator.isPartiallySelectedSubtree();

            node = node.cloneNode(!partiallySelected);
            if (partiallySelected) {
                subIterator = iterator.getSubtreeIterator();
                node.appendChild(cloneSubtree(subIterator));
                subIterator.detach(true);
            }

            if (node.nodeType == 10) {// DocumentType
                throw new DOMException("HIERARCHY_REQUEST_ERR");
            }
            frag.appendChild(node);
        }
        return frag;
    }

    function iterateSubtree(rangeIterator, func, iteratorState) {
        var it, n;
        iteratorState = iteratorState || {stop : false};
        for (var node, subRangeIterator;
             node = rangeIterator.next();) {
            //log.debug("iterateSubtree, partially selected: " + rangeIterator.isPartiallySelectedSubtree(), nodeToString(node));
            if (rangeIterator.isPartiallySelectedSubtree()) {
                // The node is partially selected by the Range, so we can use a new RangeIterator on the portion of the
                // node selected by the Range.
                if (func(node) === false) {
                    iteratorState.stop = true;
                    return;
                } else {
                    subRangeIterator = rangeIterator.getSubtreeIterator();
                    iterateSubtree(subRangeIterator, func, iteratorState);
                    subRangeIterator.detach(true);
                    if (iteratorState.stop) {
                        return;
                    }
                }
            } else {
                // The whole node is selected, so we can use efficient DOM iteration to iterate over the node and its
                // descendant
                it = dom.createIterator(node);
                while ((n = it.next())) {
                    if (func(n) === false) {
                        iteratorState.stop = true;
                        return;
                    }
                }
            }
        }
    }

    function deleteSubtree(iterator) {
        var subIterator;
        while (iterator.next()) {
            if (iterator.isPartiallySelectedSubtree()) {
                subIterator = iterator.getSubtreeIterator();
                deleteSubtree(subIterator);
                subIterator.detach(true);
            } else {
                iterator.remove();
            }
        }
    }

    function extractSubtree(iterator) {

        for (var node, frag = getRangeDocument(iterator.range).createDocumentFragment(), subIterator;
             node = iterator.next();) {

            if (iterator.isPartiallySelectedSubtree()) {
                node = node.cloneNode(false);
                subIterator = iterator.getSubtreeIterator();
                node.appendChild(extractSubtree(subIterator));
                subIterator.detach(true);
            } else {
                iterator.remove();
            }
            if (node.nodeType == 10) {// DocumentType
                throw new DOMException("HIERARCHY_REQUEST_ERR");
            }
            frag.appendChild(node);
        }
        return frag;
    }

    function getNodesInRange(range, nodeTypes, filter) {
        //log.info("getNodesInRange, " + nodeTypes.join(","));
        var filterNodeTypes = !!(nodeTypes && nodeTypes.length), regex;
        var filterExists = !!filter;
        if (filterNodeTypes) {
            regex = new RegExp("^(" + nodeTypes.join("|") + ")$");
        }

        var nodes = [];
        iterateSubtree(new RangeIterator(range, false), function (node) {
            if ((!filterNodeTypes || regex.test(node.nodeType)) && (!filterExists || filter(node))) {
                nodes.push(node);
            }
        });
        return nodes;
    }

    function inspect(range) {
        var name = (typeof range.getName == "undefined") ? "Range" : range.getName();
        return "[" + name + "(" + dom.inspectNode(range.startContainer) + ":" + range.startOffset + ", " +
            dom.inspectNode(range.endContainer) + ":" + range.endOffset + ")]";
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    // RangeIterator code partially borrows from IERange by Tim Ryan (http://github.com/timcameronryan/IERange)

    /**
     * @constructor
     */
    function RangeIterator(range, clonePartiallySelectedTextNodes) {
        this.range = range;
        this.clonePartiallySelectedTextNodes = clonePartiallySelectedTextNodes;

        if (!range.collapsed) {
            this.sc = range.startContainer;
            this.so = range.startOffset;
            this.ec = range.endContainer;
            this.eo = range.endOffset;
            var root = range.commonAncestorContainer;

            if (this.sc === this.ec && dom.isCharacterDataNode(this.sc)) {
                this.isSingleCharacterDataNode = true;
                this._first = this._last = this._next = this.sc;
            } else {
                this._first = this._next = (this.sc === root && !dom.isCharacterDataNode(this.sc)) ?
                    this.sc.childNodes[this.so] : dom.getClosestAncestorIn(this.sc, root, true);
                this._last = (this.ec === root && !dom.isCharacterDataNode(this.ec)) ?
                    this.ec.childNodes[this.eo - 1] : dom.getClosestAncestorIn(this.ec, root, true);
            }
        }
    }

    RangeIterator.prototype = {
        _current : null,
        _next : null,
        _first : null,
        _last : null,
        isSingleCharacterDataNode : false,

        reset : function () {
            this._current = null;
            this._next = this._first;
        },

        hasNext : function () {
            return !!this._next;
        },

        next : function () {
            // Move to next node
            var current = this._current = this._next;
            if (current) {
                this._next = (current !== this._last) ? current.nextSibling : null;

                // Check for partially selected text nodes
                if (dom.isCharacterDataNode(current) && this.clonePartiallySelectedTextNodes) {
                    if (current === this.ec) {

                        (current = current.cloneNode(true)).deleteData(this.eo, current.length - this.eo);
                    }
                    if (this._current === this.sc) {

                        (current = current.cloneNode(true)).deleteData(0, this.so);
                    }
                }
            }

            return current;
        },

        remove : function () {
            var current = this._current, start, end;

            if (dom.isCharacterDataNode(current) && (current === this.sc || current === this.ec)) {
                start = (current === this.sc) ? this.so : 0;
                end = (current === this.ec) ? this.eo : current.length;
                if (start != end) {
                    current.deleteData(start, end - start);
                }
            } else {
                if (current.parentNode) {
                    current.parentNode.removeChild(current);
                } else {
                }
            }
        },

        // Checks if the current node is partially selected
        isPartiallySelectedSubtree : function () {
            var current = this._current;
            return isNonTextPartiallySelected(current, this.range);
        },

        getSubtreeIterator : function () {
            var subRange;
            if (this.isSingleCharacterDataNode) {
                subRange = this.range.cloneRange();
                subRange.collapse();
            } else {
                subRange = new Range(getRangeDocument(this.range));
                var current = this._current;
                var startContainer = current, startOffset = 0, endContainer = current,
                    endOffset = dom.getNodeLength(current);

                if (dom.isAncestorOf(current, this.sc, true)) {
                    startContainer = this.sc;
                    startOffset = this.so;
                }
                if (dom.isAncestorOf(current, this.ec, true)) {
                    endContainer = this.ec;
                    endOffset = this.eo;
                }

                updateBoundaries(subRange, startContainer, startOffset, endContainer, endOffset);
            }
            return new RangeIterator(subRange, this.clonePartiallySelectedTextNodes);
        },

        detach : function (detachRange) {
            if (detachRange) {
                this.range.detach();
            }
            this.range = this._current = this._next = this._first = this._last = this.sc = this.so = this.ec = this.eo = null;
        }
    };

    /*----------------------------------------------------------------------------------------------------------------*/

    // Exceptions

    /**
     * @constructor
     */
    function RangeException(codeName) {
        this.code = this[codeName];
        this.codeName = codeName;
        this.message = "RangeException: " + this.codeName;
    }

    RangeException.prototype = {
        BAD_BOUNDARYPOINTS_ERR : 1,
        INVALID_NODE_TYPE_ERR : 2
    };

    RangeException.prototype.toString = function () {
        return this.message;
    };

    /*----------------------------------------------------------------------------------------------------------------*/

    /**
     * Currently iterates through all nodes in the range on creation until I think of a decent way to do it
     * TODO: Look into making this a proper iterator, not requiring preloading everything first
     * @constructor
     */
    function RangeNodeIterator(range, nodeTypes, filter) {
        this.nodes = getNodesInRange(range, nodeTypes, filter);
        this._next = this.nodes[0];
        this._position = 0;
    }

    RangeNodeIterator.prototype = {
        _current : null,

        hasNext : function () {
            return !!this._next;
        },

        next : function () {
            this._current = this._next;
            this._next = this.nodes[++this._position];
            return this._current;
        },

        detach : function () {
            this._current = this._next = this.nodes = null;
        }
    };

    var beforeAfterNodeTypes = [1, 3, 4, 5, 7, 8, 10];
    var rootContainerNodeTypes = [2, 9, 11];
    var readonlyNodeTypes = [5, 6, 10, 12];
    var insertableNodeTypes = [1, 3, 4, 5, 7, 8, 10, 11];
    var surroundNodeTypes = [1, 3, 4, 5, 7, 8];

    function createAncestorFinder(nodeTypes) {
        return function (node, selfIsAncestor) {
            var t, n = selfIsAncestor ? node : node.parentNode;
            while (n) {
                t = n.nodeType;
                if (dom.arrayContains(nodeTypes, t)) {
                    return n;
                }
                n = n.parentNode;
            }
            return null;
        };
    }

    var getRootContainer = dom.getRootContainer;
    var getDocumentOrFragmentContainer = createAncestorFinder([9, 11]);
    var getReadonlyAncestor = createAncestorFinder(readonlyNodeTypes);
    var getDocTypeNotationEntityAncestor = createAncestorFinder([6, 10, 12]);

    function assertNoDocTypeNotationEntityAncestor(node, allowSelf) {
        if (getDocTypeNotationEntityAncestor(node, allowSelf)) {
            throw new RangeException("INVALID_NODE_TYPE_ERR");
        }
    }

    function assertNotDetached(range) {
        if (!range.startContainer) {
            throw new DOMException("INVALID_STATE_ERR");
        }
    }

    function assertValidNodeType(node, invalidTypes) {
        if (!dom.arrayContains(invalidTypes, node.nodeType)) {
            throw new RangeException("INVALID_NODE_TYPE_ERR");
        }
    }

    function assertValidOffset(node, offset) {
        if (offset < 0 || offset > (dom.isCharacterDataNode(node) ? node.length : node.childNodes.length)) {
            throw new DOMException("INDEX_SIZE_ERR");
        }
    }

    function assertSameDocumentOrFragment(node1, node2) {
        if (getDocumentOrFragmentContainer(node1, true) !== getDocumentOrFragmentContainer(node2, true)) {
            throw new DOMException("WRONG_DOCUMENT_ERR");
        }
    }

    function assertNodeNotReadOnly(node) {
        if (getReadonlyAncestor(node, true)) {
            throw new DOMException("NO_MODIFICATION_ALLOWED_ERR");
        }
    }

    function assertNode(node, codeName) {
        if (!node) {
            throw new DOMException(codeName);
        }
    }

    function isOrphan(node) {
        return !dom.arrayContains(rootContainerNodeTypes, node.nodeType) && !getDocumentOrFragmentContainer(node, true);
    }

    function isValidOffset(node, offset) {
        return offset <= (dom.isCharacterDataNode(node) ? node.length : node.childNodes.length);
    }

    function assertRangeValid(range) {
        assertNotDetached(range);
        if (isOrphan(range.startContainer) || isOrphan(range.endContainer) || !isValidOffset(range.startContainer, range.startOffset) || !isValidOffset(range.endContainer, range.endOffset)) {
            throw new Error("Range error: Range is no longer valid after DOM mutation (" + range.inspect() + ")");
        }
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    // Test the browser's innerHTML support to decide how to implement createContextualFragment
    var styleEl = document.createElement("style");
    var htmlParsingConforms = false;
    try {
        styleEl.innerHTML = "<b>x</b>";
        htmlParsingConforms = (styleEl.firstChild.nodeType == 3); // Opera incorrectly creates an element node
    } catch (e) {
        // IE 6 and 7 throw
    }

    api.features.htmlParsingConforms = htmlParsingConforms;

    var createContextualFragment = htmlParsingConforms ?

        // Implementation as per HTML parsing spec, trusting in the browser's implementation of innerHTML. See
        // discussion and base code for this implementation at issue 67.
        // Spec: http://html5.org/specs/dom-parsing.html#extensions-to-the-range-interface
        // Thanks to Aleks Williams.
        function (fragmentStr) {
            // "Let node the context object's start's node."
            var node = this.startContainer;
            var doc = dom.getDocument(node);

            // "If the context object's start's node is null, raise an INVALID_STATE_ERR
            // exception and abort these steps."
            if (!node) {
                throw new DOMException("INVALID_STATE_ERR");
            }

            // "Let element be as follows, depending on node's interface:"
            // Document, Document Fragment: null
            var el = null;

            // "Element: node"
            if (node.nodeType == 1) {
                el = node;

                // "Text, Comment: node's parentElement"
            } else if (dom.isCharacterDataNode(node)) {
                el = dom.parentElement(node);
            }

            // "If either element is null or element's ownerDocument is an HTML document
            // and element's local name is "html" and element's namespace is the HTML
            // namespace"
            if (el === null || (
                    el.nodeName == "HTML" && dom.isHtmlNamespace(dom.getDocument(el).documentElement) && dom.isHtmlNamespace(el)
                )) {

                // "let element be a new Element with "body" as its local name and the HTML
                // namespace as its namespace.""
                el = doc.createElement("body");
            } else {
                el = el.cloneNode(false);
            }

            // "If the node's document is an HTML document: Invoke the HTML fragment parsing algorithm."
            // "If the node's document is an XML document: Invoke the XML fragment parsing algorithm."
            // "In either case, the algorithm must be invoked with fragment as the input
            // and element as the context element."
            el.innerHTML = fragmentStr;

            // "If this raises an exception, then abort these steps. Otherwise, let new
            // children be the nodes returned."

            // "Let fragment be a new DocumentFragment."
            // "Append all new children to fragment."
            // "Return fragment."
            return dom.fragmentFromNodeChildren(el);
        } :

        // In this case, innerHTML cannot be trusted, so fall back to a simpler, non-conformant implementation that
        // previous versions of Rangy used (with the exception of using a body element rather than a div)
        function (fragmentStr) {
            assertNotDetached(this);
            var doc = getRangeDocument(this);
            var el = doc.createElement("body");
            el.innerHTML = fragmentStr;

            return dom.fragmentFromNodeChildren(el);
        };

    /*----------------------------------------------------------------------------------------------------------------*/

    var rangeProperties = ["startContainer", "startOffset", "endContainer", "endOffset", "collapsed",
        "commonAncestorContainer"];

    var s2s = 0, s2e = 1, e2e = 2, e2s = 3;
    var n_b = 0, n_a = 1, n_b_a = 2, n_i = 3;

    function RangePrototype() {
    }

    RangePrototype.prototype = {
        attachListener : function (type, listener) {
            this._listeners[type].push(listener);
        },

        compareBoundaryPoints : function (how, range) {
            assertRangeValid(this);
            assertSameDocumentOrFragment(this.startContainer, range.startContainer);

            var nodeA, offsetA, nodeB, offsetB;
            var prefixA = (how == e2s || how == s2s) ? "start" : "end";
            var prefixB = (how == s2e || how == s2s) ? "start" : "end";
            nodeA = this[prefixA + "Container"];
            offsetA = this[prefixA + "Offset"];
            nodeB = range[prefixB + "Container"];
            offsetB = range[prefixB + "Offset"];
            return dom.comparePoints(nodeA, offsetA, nodeB, offsetB);
        },

        insertNode : function (node) {
            assertRangeValid(this);
            assertValidNodeType(node, insertableNodeTypes);
            assertNodeNotReadOnly(this.startContainer);

            if (dom.isAncestorOf(node, this.startContainer, true)) {
                throw new DOMException("HIERARCHY_REQUEST_ERR");
            }

            // No check for whether the container of the start of the Range is of a type that does not allow
            // children of the type of node: the browser's DOM implementation should do this for us when we attempt
            // to add the node

            var firstNodeInserted = insertNodeAtPosition(node, this.startContainer, this.startOffset);
            this.setStartBefore(firstNodeInserted);
        },

        cloneContents : function () {
            assertRangeValid(this);

            var clone, frag;
            if (this.collapsed) {
                return getRangeDocument(this).createDocumentFragment();
            } else {
                if (this.startContainer === this.endContainer && dom.isCharacterDataNode(this.startContainer)) {
                    clone = this.startContainer.cloneNode(true);
                    clone.data = clone.data.slice(this.startOffset, this.endOffset);
                    frag = getRangeDocument(this).createDocumentFragment();
                    frag.appendChild(clone);
                    return frag;
                } else {
                    var iterator = new RangeIterator(this, true);
                    clone = cloneSubtree(iterator);
                    iterator.detach();
                }
                return clone;
            }
        },

        canSurroundContents : function () {
            assertRangeValid(this);
            assertNodeNotReadOnly(this.startContainer);
            assertNodeNotReadOnly(this.endContainer);

            // Check if the contents can be surrounded. Specifically, this means whether the range partially selects
            // no non-text nodes.
            var iterator = new RangeIterator(this, true);
            var boundariesInvalid = (iterator._first && (isNonTextPartiallySelected(iterator._first, this)) ||
            (iterator._last && isNonTextPartiallySelected(iterator._last, this)));
            iterator.detach();
            return !boundariesInvalid;
        },

        surroundContents : function (node) {
            assertValidNodeType(node, surroundNodeTypes);

            if (!this.canSurroundContents()) {
                throw new RangeException("BAD_BOUNDARYPOINTS_ERR");
            }

            // Extract the contents
            var content = this.extractContents();

            // Clear the children of the node
            if (node.hasChildNodes()) {
                while (node.lastChild) {
                    node.removeChild(node.lastChild);
                }
            }

            // Insert the new node and add the extracted contents
            insertNodeAtPosition(node, this.startContainer, this.startOffset);
            node.appendChild(content);

            this.selectNode(node);
        },

        cloneRange : function () {
            assertRangeValid(this);
            var range = new Range(getRangeDocument(this));
            var i = rangeProperties.length, prop;
            while (i--) {
                prop = rangeProperties[i];
                range[prop] = this[prop];
            }
            return range;
        },

        toString : function () {
            assertRangeValid(this);
            var sc = this.startContainer;
            if (sc === this.endContainer && dom.isCharacterDataNode(sc)) {
                return (sc.nodeType == 3 || sc.nodeType == 4) ? sc.data.slice(this.startOffset, this.endOffset) : "";
            } else {
                var textBits = [], iterator = new RangeIterator(this, true);

                iterateSubtree(iterator, function (node) {
                    // Accept only text or CDATA nodes, not comments

                    if (node.nodeType == 3 || node.nodeType == 4) {
                        textBits.push(node.data);
                    }
                });
                iterator.detach();
                return textBits.join("");
            }
        },

        // The methods below are all non-standard. The following batch were introduced by Mozilla but have since
        // been removed from Mozilla.

        compareNode : function (node) {
            assertRangeValid(this);

            var parent = node.parentNode;
            var nodeIndex = dom.getNodeIndex(node);

            if (!parent) {
                throw new DOMException("NOT_FOUND_ERR");
            }

            var startComparison = this.comparePoint(parent, nodeIndex),
                endComparison = this.comparePoint(parent, nodeIndex + 1);

            if (startComparison < 0) {// Node starts before
                return (endComparison > 0) ? n_b_a : n_b;
            } else {
                return (endComparison > 0) ? n_a : n_i;
            }
        },

        comparePoint : function (node, offset) {
            assertRangeValid(this);
            assertNode(node, "HIERARCHY_REQUEST_ERR");
            assertSameDocumentOrFragment(node, this.startContainer);

            if (dom.comparePoints(node, offset, this.startContainer, this.startOffset) < 0) {
                return -1;
            } else if (dom.comparePoints(node, offset, this.endContainer, this.endOffset) > 0) {
                return 1;
            }
            return 0;
        },

        createContextualFragment : createContextualFragment,

        toHtml : function () {
            assertRangeValid(this);
            var container = getRangeDocument(this).createElement("div");
            container.appendChild(this.cloneContents());
            return container.innerHTML;
        },

        // touchingIsIntersecting determines whether this method considers a node that borders a range intersects
        // with it (as in WebKit) or not (as in Gecko pre-1.9, and the default)
        intersectsNode : function (node, touchingIsIntersecting) {
            assertRangeValid(this);
            assertNode(node, "NOT_FOUND_ERR");
            if (dom.getDocument(node) !== getRangeDocument(this)) {
                return false;
            }

            var parent = node.parentNode, offset = dom.getNodeIndex(node);
            assertNode(parent, "NOT_FOUND_ERR");

            var startComparison = dom.comparePoints(parent, offset, this.endContainer, this.endOffset),
                endComparison = dom.comparePoints(parent, offset + 1, this.startContainer, this.startOffset);

            return touchingIsIntersecting ? startComparison <= 0 && endComparison >= 0 : startComparison < 0 && endComparison > 0;
        },

        isPointInRange : function (node, offset) {
            assertRangeValid(this);
            assertNode(node, "HIERARCHY_REQUEST_ERR");
            assertSameDocumentOrFragment(node, this.startContainer);

            return (dom.comparePoints(node, offset, this.startContainer, this.startOffset) >= 0) && (dom.comparePoints(node, offset, this.endContainer, this.endOffset) <= 0);
        },

        // The methods below are non-standard and invented by me.

        // Sharing a boundary start-to-end or end-to-start does not count as intersection.
        intersectsRange : function (range, touchingIsIntersecting) {
            assertRangeValid(this);

            if (getRangeDocument(range) != getRangeDocument(this)) {
                throw new DOMException("WRONG_DOCUMENT_ERR");
            }

            var startComparison = dom.comparePoints(this.startContainer, this.startOffset, range.endContainer, range.endOffset),
                endComparison = dom.comparePoints(this.endContainer, this.endOffset, range.startContainer, range.startOffset);

            return touchingIsIntersecting ? startComparison <= 0 && endComparison >= 0 : startComparison < 0 && endComparison > 0;
        },

        intersection : function (range) {
            if (this.intersectsRange(range)) {
                var startComparison = dom.comparePoints(this.startContainer, this.startOffset, range.startContainer, range.startOffset),
                    endComparison = dom.comparePoints(this.endContainer, this.endOffset, range.endContainer, range.endOffset);

                var intersectionRange = this.cloneRange();

                if (startComparison == -1) {
                    intersectionRange.setStart(range.startContainer, range.startOffset);
                }
                if (endComparison == 1) {
                    intersectionRange.setEnd(range.endContainer, range.endOffset);
                }
                return intersectionRange;
            }
            return null;
        },

        union : function (range) {
            if (this.intersectsRange(range, true)) {
                var unionRange = this.cloneRange();
                if (dom.comparePoints(range.startContainer, range.startOffset, this.startContainer, this.startOffset) == -1) {
                    unionRange.setStart(range.startContainer, range.startOffset);
                }
                if (dom.comparePoints(range.endContainer, range.endOffset, this.endContainer, this.endOffset) == 1) {
                    unionRange.setEnd(range.endContainer, range.endOffset);
                }
                return unionRange;
            } else {
                throw new RangeException("Ranges do not intersect");
            }
        },

        containsNode : function (node, allowPartial) {
            if (allowPartial) {
                return this.intersectsNode(node, false);
            } else {
                return this.compareNode(node) == n_i;
            }
        },

        containsNodeContents : function (node) {
            return this.comparePoint(node, 0) >= 0 && this.comparePoint(node, dom.getNodeLength(node)) <= 0;
        },

        containsRange : function (range) {
            return this.intersection(range).equals(range);
        },

        containsNodeText : function (node) {
            var nodeRange = this.cloneRange();
            nodeRange.selectNode(node);
            var textNodes = nodeRange.getNodes([3]);
            if (textNodes.length > 0) {
                nodeRange.setStart(textNodes[0], 0);
                var lastTextNode = textNodes.pop();
                nodeRange.setEnd(lastTextNode, lastTextNode.length);
                var contains = this.containsRange(nodeRange);
                nodeRange.detach();
                return contains;
            } else {
                return this.containsNodeContents(node);
            }
        },

        createNodeIterator : function (nodeTypes, filter) {
            assertRangeValid(this);
            return new RangeNodeIterator(this, nodeTypes, filter);
        },

        getNodes : function (nodeTypes, filter) {
            assertRangeValid(this);
            return getNodesInRange(this, nodeTypes, filter);
        },

        getDocument : function () {
            return getRangeDocument(this);
        },

        collapseBefore : function (node) {
            assertNotDetached(this);

            this.setEndBefore(node);
            this.collapse(false);
        },

        collapseAfter : function (node) {
            assertNotDetached(this);

            this.setStartAfter(node);
            this.collapse(true);
        },

        getName : function () {
            return "DomRange";
        },

        equals : function (range) {
            return Range.rangesEqual(this, range);
        },

        inspect : function () {
            return inspect(this);
        }
    };

    function copyComparisonConstantsToObject(obj) {
        obj.START_TO_START = s2s;
        obj.START_TO_END = s2e;
        obj.END_TO_END = e2e;
        obj.END_TO_START = e2s;

        obj.NODE_BEFORE = n_b;
        obj.NODE_AFTER = n_a;
        obj.NODE_BEFORE_AND_AFTER = n_b_a;
        obj.NODE_INSIDE = n_i;
    }

    function copyComparisonConstants(constructor) {
        copyComparisonConstantsToObject(constructor);
        copyComparisonConstantsToObject(constructor.prototype);
    }

    function createRangeContentRemover(remover, boundaryUpdater) {
        return function () {
            assertRangeValid(this);

            var sc = this.startContainer, so = this.startOffset, root = this.commonAncestorContainer;

            var iterator = new RangeIterator(this, true);

            // Work out where to position the range after content removal
            var node, boundary;
            if (sc !== root) {
                node = dom.getClosestAncestorIn(sc, root, true);
                boundary = getBoundaryAfterNode(node);
                sc = boundary.node;
                so = boundary.offset;
            }

            // Check none of the range is read-only
            iterateSubtree(iterator, assertNodeNotReadOnly);

            iterator.reset();

            // Remove the content
            var returnValue = remover(iterator);
            iterator.detach();

            // Move to the new position
            boundaryUpdater(this, sc, so, sc, so);

            return returnValue;
        };
    }

    function createPrototypeRange(constructor, boundaryUpdater, detacher) {
        function createBeforeAfterNodeSetter(isBefore, isStart) {
            return function (node) {
                assertNotDetached(this);
                assertValidNodeType(node, beforeAfterNodeTypes);
                assertValidNodeType(getRootContainer(node), rootContainerNodeTypes);

                var boundary = (isBefore ? getBoundaryBeforeNode : getBoundaryAfterNode)(node);
                (isStart ? setRangeStart : setRangeEnd)(this, boundary.node, boundary.offset);
            };
        }

        function setRangeStart(range, node, offset) {
            var ec = range.endContainer, eo = range.endOffset;
            if (node !== range.startContainer || offset !== range.startOffset) {
                // Check the root containers of the range and the new boundary, and also check whether the new boundary
                // is after the current end. In either case, collapse the range to the new position
                if (getRootContainer(node) != getRootContainer(ec) || dom.comparePoints(node, offset, ec, eo) == 1) {
                    ec = node;
                    eo = offset;
                }
                boundaryUpdater(range, node, offset, ec, eo);
            }
        }

        function setRangeEnd(range, node, offset) {
            var sc = range.startContainer, so = range.startOffset;
            if (node !== range.endContainer || offset !== range.endOffset) {
                // Check the root containers of the range and the new boundary, and also check whether the new boundary
                // is after the current end. In either case, collapse the range to the new position
                if (getRootContainer(node) != getRootContainer(sc) || dom.comparePoints(node, offset, sc, so) == -1) {
                    sc = node;
                    so = offset;
                }
                boundaryUpdater(range, sc, so, node, offset);
            }
        }

        function setRangeStartAndEnd(range, node, offset) {
            if (node !== range.startContainer || offset !== range.startOffset || node !== range.endContainer || offset !== range.endOffset) {
                boundaryUpdater(range, node, offset, node, offset);
            }
        }

        constructor.prototype = new RangePrototype();

        api.util.extend(constructor.prototype, {
            setStart : function (node, offset) {
                assertNotDetached(this);
                assertNoDocTypeNotationEntityAncestor(node, true);
                assertValidOffset(node, offset);

                setRangeStart(this, node, offset);
            },

            setEnd : function (node, offset) {
                assertNotDetached(this);
                assertNoDocTypeNotationEntityAncestor(node, true);
                assertValidOffset(node, offset);

                setRangeEnd(this, node, offset);
            },

            setStartBefore : createBeforeAfterNodeSetter(true, true),
            setStartAfter : createBeforeAfterNodeSetter(false, true),
            setEndBefore : createBeforeAfterNodeSetter(true, false),
            setEndAfter : createBeforeAfterNodeSetter(false, false),

            collapse : function (isStart) {
                assertRangeValid(this);
                if (isStart) {
                    boundaryUpdater(this, this.startContainer, this.startOffset, this.startContainer, this.startOffset);
                } else {
                    boundaryUpdater(this, this.endContainer, this.endOffset, this.endContainer, this.endOffset);
                }
            },

            selectNodeContents : function (node) {
                // This doesn't seem well specified: the spec talks only about selecting the node's contents, which
                // could be taken to mean only its children. However, browsers implement this the same as selectNode for
                // text nodes, so I shall do likewise
                assertNotDetached(this);
                assertNoDocTypeNotationEntityAncestor(node, true);

                boundaryUpdater(this, node, 0, node, dom.getNodeLength(node));
            },

            selectNode : function (node) {
                assertNotDetached(this);
                assertNoDocTypeNotationEntityAncestor(node, false);
                assertValidNodeType(node, beforeAfterNodeTypes);

                var start = getBoundaryBeforeNode(node), end = getBoundaryAfterNode(node);
                boundaryUpdater(this, start.node, start.offset, end.node, end.offset);
            },

            extractContents : createRangeContentRemover(extractSubtree, boundaryUpdater),

            deleteContents : createRangeContentRemover(deleteSubtree, boundaryUpdater),

            canSurroundContents : function () {
                assertRangeValid(this);
                assertNodeNotReadOnly(this.startContainer);
                assertNodeNotReadOnly(this.endContainer);

                // Check if the contents can be surrounded. Specifically, this means whether the range partially selects
                // no non-text nodes.
                var iterator = new RangeIterator(this, true);
                var boundariesInvalid = (iterator._first && (isNonTextPartiallySelected(iterator._first, this)) ||
                (iterator._last && isNonTextPartiallySelected(iterator._last, this)));
                iterator.detach();
                return !boundariesInvalid;
            },

            detach : function () {
                detacher(this);
            },

            splitBoundaries : function () {
                assertRangeValid(this);

                var sc = this.startContainer, so = this.startOffset, ec = this.endContainer, eo = this.endOffset;
                var startEndSame = (sc === ec);

                if (dom.isCharacterDataNode(ec) && eo < ec.length) {
                    dom.splitDataNode(ec, eo);
                }

                if (dom.isCharacterDataNode(sc) && so > 0) {
                    sc = dom.splitDataNode(sc, so);
                    if (startEndSame) {
                        eo -= so;
                        ec = sc;
                    } else if (ec == sc.parentNode && eo >= dom.getNodeIndex(sc)) {
                        eo++;
                    }
                    so = 0;
                }
                boundaryUpdater(this, sc, so, ec, eo);
            },

            normalizeBoundaries : function () {
                assertRangeValid(this);

                var sc = this.startContainer, so = this.startOffset, ec = this.endContainer, eo = this.endOffset;

                var mergeForward = function (node) {
                    var sibling = node.nextSibling;
                    if (sibling && sibling.nodeType == node.nodeType) {
                        ec = node;
                        eo = node.length;
                        node.appendData(sibling.data);
                        sibling.parentNode.removeChild(sibling);
                    }
                };

                var mergeBackward = function (node) {
                    var sibling = node.previousSibling;
                    if (sibling && sibling.nodeType == node.nodeType) {
                        sc = node;
                        var nodeLength = node.length;
                        so = sibling.length;
                        node.insertData(0, sibling.data);
                        sibling.parentNode.removeChild(sibling);
                        if (sc == ec) {
                            eo += so;
                            ec = sc;
                        } else if (ec == node.parentNode) {
                            var nodeIndex = dom.getNodeIndex(node);
                            if (eo == nodeIndex) {
                                ec = node;
                                eo = nodeLength;
                            } else if (eo > nodeIndex) {
                                eo--;
                            }
                        }
                    }
                };

                var normalizeStart = true;

                if (dom.isCharacterDataNode(ec)) {
                    if (ec.length == eo) {
                        mergeForward(ec);
                    }
                } else {
                    if (eo > 0) {
                        var endNode = ec.childNodes[eo - 1];
                        if (endNode && dom.isCharacterDataNode(endNode)) {
                            mergeForward(endNode);
                        }
                    }
                    normalizeStart = !this.collapsed;
                }

                if (normalizeStart) {
                    if (dom.isCharacterDataNode(sc)) {
                        if (so == 0) {
                            mergeBackward(sc);
                        }
                    } else {
                        if (so < sc.childNodes.length) {
                            var startNode = sc.childNodes[so];
                            if (startNode && dom.isCharacterDataNode(startNode)) {
                                mergeBackward(startNode);
                            }
                        }
                    }
                } else {
                    sc = ec;
                    so = eo;
                }

                boundaryUpdater(this, sc, so, ec, eo);
            },

            collapseToPoint : function (node, offset) {
                assertNotDetached(this);

                assertNoDocTypeNotationEntityAncestor(node, true);
                assertValidOffset(node, offset);

                setRangeStartAndEnd(this, node, offset);
            }
        });

        copyComparisonConstants(constructor);
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    // Updates commonAncestorContainer and collapsed after boundary change
    function updateCollapsedAndCommonAncestor(range) {
        range.collapsed = (range.startContainer === range.endContainer && range.startOffset === range.endOffset);
        range.commonAncestorContainer = range.collapsed ?
            range.startContainer : dom.getCommonAncestor(range.startContainer, range.endContainer);
    }

    function updateBoundaries(range, startContainer, startOffset, endContainer, endOffset) {
        var startMoved = (range.startContainer !== startContainer || range.startOffset !== startOffset);
        var endMoved = (range.endContainer !== endContainer || range.endOffset !== endOffset);

        range.startContainer = startContainer;
        range.startOffset = startOffset;
        range.endContainer = endContainer;
        range.endOffset = endOffset;

        updateCollapsedAndCommonAncestor(range);
        dispatchEvent(range, "boundarychange", {startMoved : startMoved, endMoved : endMoved});
    }

    function detach(range) {
        assertNotDetached(range);
        range.startContainer = range.startOffset = range.endContainer = range.endOffset = null;
        range.collapsed = range.commonAncestorContainer = null;
        dispatchEvent(range, "detach", null);
        range._listeners = null;
    }

    /**
     * @constructor
     */
    function Range(doc) {
        this.startContainer = doc;
        this.startOffset = 0;
        this.endContainer = doc;
        this.endOffset = 0;
        this._listeners = {
            boundarychange : [],
            detach : []
        };
        updateCollapsedAndCommonAncestor(this);
    }

    createPrototypeRange(Range, updateBoundaries, detach);

    api.rangePrototype = RangePrototype.prototype;

    Range.rangeProperties = rangeProperties;
    Range.RangeIterator = RangeIterator;
    Range.copyComparisonConstants = copyComparisonConstants;
    Range.createPrototypeRange = createPrototypeRange;
    Range.inspect = inspect;
    Range.getRangeDocument = getRangeDocument;
    Range.rangesEqual = function (r1, r2) {
        return r1.startContainer === r2.startContainer && r1.startOffset === r2.startOffset && r1.endContainer === r2.endContainer && r1.endOffset === r2.endOffset;
    };

    api.DomRange = Range;
    api.RangeException = RangeException;
});
rangy.createModule("WrappedRange", function (api, module) {
    api.requireModules(["DomUtil", "DomRange"]);

    /**
     * @constructor
     */
    var WrappedRange;
    var dom = api.dom;
    var DomPosition = dom.DomPosition;
    var DomRange = api.DomRange;

    /*----------------------------------------------------------------------------------------------------------------*/

    /*
     This is a workaround for a bug where IE returns the wrong container element from the TextRange's parentElement()
     method. For example, in the following (where pipes denote the selection boundaries):

     <ul id="ul"><li id="a">| a </li><li id="b"> b |</li></ul>

     var range = document.selection.createRange();
     alert(range.parentElement().id); // Should alert "ul" but alerts "b"

     This method returns the common ancestor node of the following:
     - the parentElement() of the textRange
     - the parentElement() of the textRange after calling collapse(true)
     - the parentElement() of the textRange after calling collapse(false)
     */
    function getTextRangeContainerElement(textRange) {
        var parentEl = textRange.parentElement();

        var range = textRange.duplicate();
        range.collapse(true);
        var startEl = range.parentElement();
        range = textRange.duplicate();
        range.collapse(false);
        var endEl = range.parentElement();
        var startEndContainer = (startEl == endEl) ? startEl : dom.getCommonAncestor(startEl, endEl);

        return startEndContainer == parentEl ? startEndContainer : dom.getCommonAncestor(parentEl, startEndContainer);
    }

    function textRangeIsCollapsed(textRange) {
        return textRange.compareEndPoints("StartToEnd", textRange) == 0;
    }

    // Gets the boundary of a TextRange expressed as a node and an offset within that node. This function started out as
    // an improved version of code found in Tim Cameron Ryan's IERange (http://code.google.com/p/ierange/) but has
    // grown, fixing problems with line breaks in preformatted text, adding workaround for IE TextRange bugs, handling
    // for inputs and images, plus optimizations.
    function getTextRangeBoundaryPosition(textRange, wholeRangeContainerElement, isStart, isCollapsed) {
        var workingRange = textRange.duplicate();

        workingRange.collapse(isStart);
        var containerElement = workingRange.parentElement();

        // Sometimes collapsing a TextRange that's at the start of a text node can move it into the previous node, so
        // check for that
        // TODO: Find out when. Workaround for wholeRangeContainerElement may break this
        if (!dom.isAncestorOf(wholeRangeContainerElement, containerElement, true)) {
            containerElement = wholeRangeContainerElement;
        }

        // Deal with nodes that cannot "contain rich HTML markup". In practice, this means form inputs, images and
        // similar. See http://msdn.microsoft.com/en-us/library/aa703950%28VS.85%29.aspx
        if (!containerElement.canHaveHTML) {
            return new DomPosition(containerElement.parentNode, dom.getNodeIndex(containerElement));
        }

        var workingNode = dom.getDocument(containerElement).createElement("span");
        var comparison, workingComparisonType = isStart ? "StartToStart" : "StartToEnd";
        var previousNode, nextNode, boundaryPosition, boundaryNode;

        // Move the working range through the container's children, starting at the end and working backwards, until the
        // working range reaches or goes past the boundary we're interested in
        do {
            containerElement.insertBefore(workingNode, workingNode.previousSibling);
            workingRange.moveToElementText(workingNode);
        } while ((comparison = workingRange.compareEndPoints(workingComparisonType, textRange)) > 0 && workingNode.previousSibling);

        // We've now reached or gone past the boundary of the text range we're interested in
        // so have identified the node we want
        boundaryNode = workingNode.nextSibling;

        if (comparison == -1 && boundaryNode && dom.isCharacterDataNode(boundaryNode)) {
            // This is a character data node (text, comment, cdata). The working range is collapsed at the start of the
            // node containing the text range's boundary, so we move the end of the working range to the boundary point
            // and measure the length of its text to get the boundary's offset within the node.
            workingRange.setEndPoint(isStart ? "EndToStart" : "EndToEnd", textRange);

            var offset;

            if (/[\r\n]/.test(boundaryNode.data)) {
                /*
                 For the particular case of a boundary within a text node containing line breaks (within a <pre> element,
                 for example), we need a slightly complicated approach to get the boundary's offset in IE. The facts:

                 - Each line break is represented as \r in the text node's data/nodeValue properties
                 - Each line break is represented as \r\n in the TextRange's 'text' property
                 - The 'text' property of the TextRange does not contain trailing line breaks

                 To get round the problem presented by the final fact above, we can use the fact that TextRange's
                 moveStart() and moveEnd() methods return the actual number of characters moved, which is not necessarily
                 the same as the number of characters it was instructed to move. The simplest approach is to use this to
                 store the characters moved when moving both the start and end of the range to the start of the document
                 body and subtracting the start offset from the end offset (the "move-negative-gazillion" method).
                 However, this is extremely slow when the document is large and the range is near the end of it. Clearly
                 doing the mirror image (i.e. moving the range boundaries to the end of the document) has the same
                 problem.

                 Another approach that works is to use moveStart() to move the start boundary of the range up to the end
                 boundary one character at a time and incrementing a counter with the value returned by the moveStart()
                 call. However, the check for whether the start boundary has reached the end boundary is expensive, so
                 this method is slow (although unlike "move-negative-gazillion" is largely unaffected by the location of
                 the range within the document).

                 The method below is a hybrid of the two methods above. It uses the fact that a string containing the
                 TextRange's 'text' property with each \r\n converted to a single \r character cannot be longer than the
                 text of the TextRange, so the start of the range is moved that length initially and then a character at
                 a time to make up for any trailing line breaks not contained in the 'text' property. This has good
                 performance in most situations compared to the previous two methods.
                 */
                var tempRange = workingRange.duplicate();
                var rangeLength = tempRange.text.replace(/\r\n/g, "\r").length;

                offset = tempRange.moveStart("character", rangeLength);
                while ((comparison = tempRange.compareEndPoints("StartToEnd", tempRange)) == -1) {
                    offset++;
                    tempRange.moveStart("character", 1);
                }
            } else {
                offset = workingRange.text.length;
            }
            boundaryPosition = new DomPosition(boundaryNode, offset);
        } else {
            // If the boundary immediately follows a character data node and this is the end boundary, we should favour
            // a position within that, and likewise for a start boundary preceding a character data node
            previousNode = (isCollapsed || !isStart) && workingNode.previousSibling;
            nextNode = (isCollapsed || isStart) && workingNode.nextSibling;

            if (nextNode && dom.isCharacterDataNode(nextNode)) {
                boundaryPosition = new DomPosition(nextNode, 0);
            } else if (previousNode && dom.isCharacterDataNode(previousNode)) {
                boundaryPosition = new DomPosition(previousNode, previousNode.length);
            } else {
                boundaryPosition = new DomPosition(containerElement, dom.getNodeIndex(workingNode));
            }
        }

        // Clean up
        workingNode.parentNode.removeChild(workingNode);

        return boundaryPosition;
    }

    // Returns a TextRange representing the boundary of a TextRange expressed as a node and an offset within that node.
    // This function started out as an optimized version of code found in Tim Cameron Ryan's IERange
    // (http://code.google.com/p/ierange/)
    function createBoundaryTextRange(boundaryPosition, isStart) {
        var boundaryNode, boundaryParent, boundaryOffset = boundaryPosition.offset;
        var doc = dom.getDocument(boundaryPosition.node);
        var workingNode, childNodes, workingRange = doc.body.createTextRange();
        var nodeIsDataNode = dom.isCharacterDataNode(boundaryPosition.node);

        if (nodeIsDataNode) {
            boundaryNode = boundaryPosition.node;
            boundaryParent = boundaryNode.parentNode;
        } else {
            childNodes = boundaryPosition.node.childNodes;
            boundaryNode = (boundaryOffset < childNodes.length) ? childNodes[boundaryOffset] : null;
            boundaryParent = boundaryPosition.node;
        }

        // Position the range immediately before the node containing the boundary
        workingNode = doc.createElement("span");

        // Making the working element non-empty element persuades IE to consider the TextRange boundary to be within the
        // element rather than immediately before or after it, which is what we want
        workingNode.innerHTML = "&#feff;";

        // insertBefore is supposed to work like appendChild if the second parameter is null. However, a bug report
        // for IERange suggests that it can crash the browser: http://code.google.com/p/ierange/issues/detail?id=12
        if (boundaryNode) {
            boundaryParent.insertBefore(workingNode, boundaryNode);
        } else {
            boundaryParent.appendChild(workingNode);
        }

        workingRange.moveToElementText(workingNode);
        workingRange.collapse(!isStart);

        // Clean up
        boundaryParent.removeChild(workingNode);

        // Move the working range to the text offset, if required
        if (nodeIsDataNode) {
            workingRange[isStart ? "moveStart" : "moveEnd"]("character", boundaryOffset);
        }

        return workingRange;
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    if (api.features.implementsDomRange && (!api.features.implementsTextRange || !api.config.preferTextRange)) {
        // This is a wrapper around the browser's native DOM Range. It has two aims:
        // - Provide workarounds for specific browser bugs
        // - provide convenient extensions, which are inherited from Rangy's DomRange

        (function () {
            var rangeProto;
            var rangeProperties = DomRange.rangeProperties;
            var canSetRangeStartAfterEnd;

            function updateRangeProperties(range) {
                var i = rangeProperties.length, prop;
                while (i--) {
                    prop = rangeProperties[i];
                    range[prop] = range.nativeRange[prop];
                }
            }

            function updateNativeRange(range, startContainer, startOffset, endContainer, endOffset) {
                var startMoved = (range.startContainer !== startContainer || range.startOffset != startOffset);
                var endMoved = (range.endContainer !== endContainer || range.endOffset != endOffset);

                // Always set both boundaries for the benefit of IE9 (see issue 35)
                if (startMoved || endMoved) {
                    range.setEnd(endContainer, endOffset);
                    range.setStart(startContainer, startOffset);
                }
            }

            function detach(range) {
                range.nativeRange.detach();
                range.detached = true;
                var i = rangeProperties.length, prop;
                while (i--) {
                    prop = rangeProperties[i];
                    range[prop] = null;
                }
            }

            var createBeforeAfterNodeSetter;

            WrappedRange = function (range) {
                if (!range) {
                    throw new Error("Range must be specified");
                }
                this.nativeRange = range;
                updateRangeProperties(this);
            };

            DomRange.createPrototypeRange(WrappedRange, updateNativeRange, detach);

            rangeProto = WrappedRange.prototype;

            rangeProto.selectNode = function (node) {
                this.nativeRange.selectNode(node);
                updateRangeProperties(this);
            };

            rangeProto.deleteContents = function () {
                this.nativeRange.deleteContents();
                updateRangeProperties(this);
            };

            rangeProto.extractContents = function () {
                var frag = this.nativeRange.extractContents();
                updateRangeProperties(this);
                return frag;
            };

            rangeProto.cloneContents = function () {
                return this.nativeRange.cloneContents();
            };

            // TODO: Until I can find a way to programmatically trigger the Firefox bug (apparently long-standing, still
            // present in 3.6.8) that throws "Index or size is negative or greater than the allowed amount" for
            // insertNode in some circumstances, all browsers will have to use the Rangy's own implementation of
            // insertNode, which works but is almost certainly slower than the native implementation.
            /*
             rangeProto.insertNode = function(node) {
             this.nativeRange.insertNode(node);
             updateRangeProperties(this);
             };
             */

            rangeProto.surroundContents = function (node) {
                this.nativeRange.surroundContents(node);
                updateRangeProperties(this);
            };

            rangeProto.collapse = function (isStart) {
                this.nativeRange.collapse(isStart);
                updateRangeProperties(this);
            };

            rangeProto.cloneRange = function () {
                return new WrappedRange(this.nativeRange.cloneRange());
            };

            rangeProto.refresh = function () {
                updateRangeProperties(this);
            };

            rangeProto.toString = function () {
                return this.nativeRange.toString();
            };

            // Create test range and node for feature detection

            var testTextNode = document.createTextNode("test");
            dom.getBody(document).appendChild(testTextNode);
            var range = document.createRange();

            /*--------------------------------------------------------------------------------------------------------*/

            // Test for Firefox 2 bug that prevents moving the start of a Range to a point after its current end and
            // correct for it

            range.setStart(testTextNode, 0);
            range.setEnd(testTextNode, 0);

            try {
                range.setStart(testTextNode, 1);
                canSetRangeStartAfterEnd = true;

                rangeProto.setStart = function (node, offset) {
                    this.nativeRange.setStart(node, offset);
                    updateRangeProperties(this);
                };

                rangeProto.setEnd = function (node, offset) {
                    this.nativeRange.setEnd(node, offset);
                    updateRangeProperties(this);
                };

                createBeforeAfterNodeSetter = function (name) {
                    return function (node) {
                        this.nativeRange[name](node);
                        updateRangeProperties(this);
                    };
                };
            } catch (ex) {

                canSetRangeStartAfterEnd = false;

                rangeProto.setStart = function (node, offset) {
                    try {
                        this.nativeRange.setStart(node, offset);
                    } catch (ex) {
                        this.nativeRange.setEnd(node, offset);
                        this.nativeRange.setStart(node, offset);
                    }
                    updateRangeProperties(this);
                };

                rangeProto.setEnd = function (node, offset) {
                    try {
                        this.nativeRange.setEnd(node, offset);
                    } catch (ex) {
                        this.nativeRange.setStart(node, offset);
                        this.nativeRange.setEnd(node, offset);
                    }
                    updateRangeProperties(this);
                };

                createBeforeAfterNodeSetter = function (name, oppositeName) {
                    return function (node) {
                        try {
                            this.nativeRange[name](node);
                        } catch (ex) {
                            this.nativeRange[oppositeName](node);
                            this.nativeRange[name](node);
                        }
                        updateRangeProperties(this);
                    };
                };
            }

            rangeProto.setStartBefore = createBeforeAfterNodeSetter("setStartBefore", "setEndBefore");
            rangeProto.setStartAfter = createBeforeAfterNodeSetter("setStartAfter", "setEndAfter");
            rangeProto.setEndBefore = createBeforeAfterNodeSetter("setEndBefore", "setStartBefore");
            rangeProto.setEndAfter = createBeforeAfterNodeSetter("setEndAfter", "setStartAfter");

            /*--------------------------------------------------------------------------------------------------------*/

            // Test for and correct Firefox 2 behaviour with selectNodeContents on text nodes: it collapses the range to
            // the 0th character of the text node
            range.selectNodeContents(testTextNode);
            if (range.startContainer == testTextNode && range.endContainer == testTextNode && range.startOffset == 0 && range.endOffset == testTextNode.length) {
                rangeProto.selectNodeContents = function (node) {
                    this.nativeRange.selectNodeContents(node);
                    updateRangeProperties(this);
                };
            } else {
                rangeProto.selectNodeContents = function (node) {
                    this.setStart(node, 0);
                    this.setEnd(node, DomRange.getEndOffset(node));
                };
            }

            /*--------------------------------------------------------------------------------------------------------*/

            // Test for WebKit bug that has the beahviour of compareBoundaryPoints round the wrong way for constants
            // START_TO_END and END_TO_START: https://bugs.webkit.org/show_bug.cgi?id=20738

            range.selectNodeContents(testTextNode);
            range.setEnd(testTextNode, 3);

            var range2 = document.createRange();
            range2.selectNodeContents(testTextNode);
            range2.setEnd(testTextNode, 4);
            range2.setStart(testTextNode, 2);

            if (range.compareBoundaryPoints(range.START_TO_END, range2) == -1 &
                range.compareBoundaryPoints(range.END_TO_START, range2) == 1) {
                // This is the wrong way round, so correct for it

                rangeProto.compareBoundaryPoints = function (type, range) {
                    range = range.nativeRange || range;
                    if (type == range.START_TO_END) {
                        type = range.END_TO_START;
                    } else if (type == range.END_TO_START) {
                        type = range.START_TO_END;
                    }
                    return this.nativeRange.compareBoundaryPoints(type, range);
                };
            } else {
                rangeProto.compareBoundaryPoints = function (type, range) {
                    return this.nativeRange.compareBoundaryPoints(type, range.nativeRange || range);
                };
            }

            /*--------------------------------------------------------------------------------------------------------*/

            // Test for existence of createContextualFragment and delegate to it if it exists
            if (api.util.isHostMethod(range, "createContextualFragment")) {
                rangeProto.createContextualFragment = function (fragmentStr) {
                    return this.nativeRange.createContextualFragment(fragmentStr);
                };
            }

            /*--------------------------------------------------------------------------------------------------------*/

            // Clean up
            dom.getBody(document).removeChild(testTextNode);
            range.detach();
            range2.detach();
        })();

        api.createNativeRange = function (doc) {
            doc = doc || document;
            return doc.createRange();
        };
    } else if (api.features.implementsTextRange) {
        // This is a wrapper around a TextRange, providing full DOM Range functionality using rangy's DomRange as a
        // prototype

        WrappedRange = function (textRange) {
            this.textRange = textRange;
            this.refresh();
        };

        WrappedRange.prototype = new DomRange(document);

        WrappedRange.prototype.refresh = function () {
            var start, end;

            // TextRange's parentElement() method cannot be trusted. getTextRangeContainerElement() works around that.
            var rangeContainerElement = getTextRangeContainerElement(this.textRange);

            if (textRangeIsCollapsed(this.textRange)) {
                end = start = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, true, true);
            } else {

                start = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, true, false);
                end = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, false, false);
            }

            this.setStart(start.node, start.offset);
            this.setEnd(end.node, end.offset);
        };

        DomRange.copyComparisonConstants(WrappedRange);

        // Add WrappedRange as the Range property of the global object to allow expression like Range.END_TO_END to work
        var globalObj = (function () {
            return this;
        })();
        if (typeof globalObj.Range == "undefined") {
            globalObj.Range = WrappedRange;
        }

        api.createNativeRange = function (doc) {
            doc = doc || document;
            return doc.body.createTextRange();
        };
    }

    if (api.features.implementsTextRange) {
        WrappedRange.rangeToTextRange = function (range) {
            if (range.collapsed) {
                var tr = createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);

                return tr;

                //return createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);
            } else {
                var startRange = createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);
                var endRange = createBoundaryTextRange(new DomPosition(range.endContainer, range.endOffset), false);
                var textRange = dom.getDocument(range.startContainer).body.createTextRange();
                textRange.setEndPoint("StartToStart", startRange);
                textRange.setEndPoint("EndToEnd", endRange);
                return textRange;
            }
        };
    }

    WrappedRange.prototype.getName = function () {
        return "WrappedRange";
    };

    api.WrappedRange = WrappedRange;

    api.createRange = function (doc) {
        doc = doc || document;
        return new WrappedRange(api.createNativeRange(doc));
    };

    api.createRangyRange = function (doc) {
        doc = doc || document;
        return new DomRange(doc);
    };

    api.createIframeRange = function (iframeEl) {
        return api.createRange(dom.getIframeDocument(iframeEl));
    };

    api.createIframeRangyRange = function (iframeEl) {
        return api.createRangyRange(dom.getIframeDocument(iframeEl));
    };

    api.addCreateMissingNativeApiListener(function (win) {
        var doc = win.document;
        if (typeof doc.createRange == "undefined") {
            doc.createRange = function () {
                return api.createRange(this);
            };
        }
        doc = win = null;
    });
});
rangy.createModule("WrappedSelection", function (api, module) {
    // This will create a selection object wrapper that follows the Selection object found in the WHATWG draft DOM Range
    // spec (http://html5.org/specs/dom-range.html)

    api.requireModules(["DomUtil", "DomRange", "WrappedRange"]);

    api.config.checkSelectionRanges = true;

    var BOOLEAN = "boolean",
        windowPropertyName = "_rangySelection",
        dom = api.dom,
        util = api.util,
        DomRange = api.DomRange,
        WrappedRange = api.WrappedRange,
        DOMException = api.DOMException,
        DomPosition = dom.DomPosition,
        getSelection,
        selectionIsCollapsed,
        CONTROL = "Control";

    function getWinSelection(winParam) {
        return (winParam || window).getSelection();
    }

    function getDocSelection(winParam) {
        return (winParam || window).document.selection;
    }

    // Test for the Range/TextRange and Selection features required
    // Test for ability to retrieve selection
    var implementsWinGetSelection = api.util.isHostMethod(window, "getSelection"),
        implementsDocSelection = api.util.isHostObject(document, "selection");

    var useDocumentSelection = implementsDocSelection && (!implementsWinGetSelection || api.config.preferTextRange);

    if (useDocumentSelection) {
        getSelection = getDocSelection;
        api.isSelectionValid = function (winParam) {
            var doc = (winParam || window).document, nativeSel = doc.selection;

            // Check whether the selection TextRange is actually contained within the correct document
            return (nativeSel.type != "None" || dom.getDocument(nativeSel.createRange().parentElement()) == doc);
        };
    } else if (implementsWinGetSelection) {
        getSelection = getWinSelection;
        api.isSelectionValid = function () {
            return true;
        };
    } else {
        module.fail("Neither document.selection or window.getSelection() detected.");
    }

    api.getNativeSelection = getSelection;

    var testSelection = getSelection();
    var testRange = api.createNativeRange(document);
    var body = dom.getBody(document);

    // Obtaining a range from a selection
    var selectionHasAnchorAndFocus = util.areHostObjects(testSelection, ["anchorNode", "focusNode"] && util.areHostProperties(testSelection, ["anchorOffset", "focusOffset"]));
    api.features.selectionHasAnchorAndFocus = selectionHasAnchorAndFocus;

    // Test for existence of native selection extend() method
    var selectionHasExtend = util.isHostMethod(testSelection, "extend");
    api.features.selectionHasExtend = selectionHasExtend;

    // Test if rangeCount exists
    var selectionHasRangeCount = (typeof testSelection.rangeCount == "number");
    api.features.selectionHasRangeCount = selectionHasRangeCount;

    var selectionSupportsMultipleRanges = false;
    var collapsedNonEditableSelectionsSupported = true;

    if (util.areHostMethods(testSelection, ["addRange", "getRangeAt", "removeAllRanges"]) && typeof testSelection.rangeCount == "number" && api.features.implementsDomRange) {

        (function () {
            var iframe = document.createElement("iframe");
            body.appendChild(iframe);

            var iframeDoc = dom.getIframeDocument(iframe);
            iframeDoc.open();
            iframeDoc.write("<html><head></head><body>12</body></html>");
            iframeDoc.close();

            var sel = dom.getIframeWindow(iframe).getSelection();
            var docEl = iframeDoc.documentElement;
            var iframeBody = docEl.lastChild, textNode = iframeBody.firstChild;

            // Test whether the native selection will allow a collapsed selection within a non-editable element
            var r1 = iframeDoc.createRange();
            r1.setStart(textNode, 1);
            r1.collapse(true);
            sel.addRange(r1);
            collapsedNonEditableSelectionsSupported = (sel.rangeCount == 1);
            sel.removeAllRanges();

            // Test whether the native selection is capable of supporting multiple ranges
            var r2 = r1.cloneRange();
            r1.setStart(textNode, 0);
            r2.setEnd(textNode, 2);
            sel.addRange(r1);
            sel.addRange(r2);

            selectionSupportsMultipleRanges = (sel.rangeCount == 2);

            // Clean up
            r1.detach();
            r2.detach();

            body.removeChild(iframe);
        })();
    }

    api.features.selectionSupportsMultipleRanges = selectionSupportsMultipleRanges;
    api.features.collapsedNonEditableSelectionsSupported = collapsedNonEditableSelectionsSupported;

    // ControlRanges
    var implementsControlRange = false, testControlRange;

    if (body && util.isHostMethod(body, "createControlRange")) {
        testControlRange = body.createControlRange();
        if (util.areHostProperties(testControlRange, ["item", "add"])) {
            implementsControlRange = true;
        }
    }
    api.features.implementsControlRange = implementsControlRange;

    // Selection collapsedness
    if (selectionHasAnchorAndFocus) {
        selectionIsCollapsed = function (sel) {
            return sel.anchorNode === sel.focusNode && sel.anchorOffset === sel.focusOffset;
        };
    } else {
        selectionIsCollapsed = function (sel) {
            return sel.rangeCount ? sel.getRangeAt(sel.rangeCount - 1).collapsed : false;
        };
    }

    function updateAnchorAndFocusFromRange(sel, range, backwards) {
        var anchorPrefix = backwards ? "end" : "start", focusPrefix = backwards ? "start" : "end";
        sel.anchorNode = range[anchorPrefix + "Container"];
        sel.anchorOffset = range[anchorPrefix + "Offset"];
        sel.focusNode = range[focusPrefix + "Container"];
        sel.focusOffset = range[focusPrefix + "Offset"];
    }

    function updateAnchorAndFocusFromNativeSelection(sel) {
        var nativeSel = sel.nativeSelection;
        sel.anchorNode = nativeSel.anchorNode;
        sel.anchorOffset = nativeSel.anchorOffset;
        sel.focusNode = nativeSel.focusNode;
        sel.focusOffset = nativeSel.focusOffset;
    }

    function updateEmptySelection(sel) {
        sel.anchorNode = sel.focusNode = null;
        sel.anchorOffset = sel.focusOffset = 0;
        sel.rangeCount = 0;
        sel.isCollapsed = true;
        sel._ranges.length = 0;
    }

    function getNativeRange(range) {
        var nativeRange;
        if (range instanceof DomRange) {
            nativeRange = range._selectionNativeRange;
            if (!nativeRange) {
                nativeRange = api.createNativeRange(dom.getDocument(range.startContainer));
                nativeRange.setEnd(range.endContainer, range.endOffset);
                nativeRange.setStart(range.startContainer, range.startOffset);
                range._selectionNativeRange = nativeRange;
                range.attachListener("detach", function () {

                    this._selectionNativeRange = null;
                });
            }
        } else if (range instanceof WrappedRange) {
            nativeRange = range.nativeRange;
        } else if (api.features.implementsDomRange && (range instanceof dom.getWindow(range.startContainer).Range)) {
            nativeRange = range;
        }
        return nativeRange;
    }

    function rangeContainsSingleElement(rangeNodes) {
        if (!rangeNodes.length || rangeNodes[0].nodeType != 1) {
            return false;
        }
        for (var i = 1, len = rangeNodes.length;
             i < len;
             ++i) {
            if (!dom.isAncestorOf(rangeNodes[0], rangeNodes[i])) {
                return false;
            }
        }
        return true;
    }

    function getSingleElementFromRange(range) {
        var nodes = range.getNodes();
        if (!rangeContainsSingleElement(nodes)) {
            throw new Error("getSingleElementFromRange: range " + range.inspect() + " did not consist of a single element");
        }
        return nodes[0];
    }

    function isTextRange(range) {
        return !!range && typeof range.text != "undefined";
    }

    function updateFromTextRange(sel, range) {
        // Create a Range from the selected TextRange
        var wrappedRange = new WrappedRange(range);
        sel._ranges = [wrappedRange];

        updateAnchorAndFocusFromRange(sel, wrappedRange, false);
        sel.rangeCount = 1;
        sel.isCollapsed = wrappedRange.collapsed;
    }

    function updateControlSelection(sel) {
        // Update the wrapped selection based on what's now in the native selection
        sel._ranges.length = 0;
        if (sel.docSelection.type == "None") {
            updateEmptySelection(sel);
        } else {
            var controlRange = sel.docSelection.createRange();
            if (isTextRange(controlRange)) {
                // This case (where the selection type is "Control" and calling createRange() on the selection returns
                // a TextRange) can happen in IE 9. It happens, for example, when all elements in the selected
                // ControlRange have been removed from the ControlRange and removed from the document.
                updateFromTextRange(sel, controlRange);
            } else {
                sel.rangeCount = controlRange.length;
                var range, doc = dom.getDocument(controlRange.item(0));
                for (var i = 0;
                     i < sel.rangeCount;
                     ++i) {
                    range = api.createRange(doc);
                    range.selectNode(controlRange.item(i));
                    sel._ranges.push(range);
                }
                sel.isCollapsed = sel.rangeCount == 1 && sel._ranges[0].collapsed;
                updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], false);
            }
        }
    }

    function addRangeToControlSelection(sel, range) {
        var controlRange = sel.docSelection.createRange();
        var rangeElement = getSingleElementFromRange(range);

        // Create a new ControlRange containing all the elements in the selected ControlRange plus the element
        // contained by the supplied range
        var doc = dom.getDocument(controlRange.item(0));
        var newControlRange = dom.getBody(doc).createControlRange();
        for (var i = 0, len = controlRange.length;
             i < len;
             ++i) {
            newControlRange.add(controlRange.item(i));
        }
        try {
            newControlRange.add(rangeElement);
        } catch (ex) {
            throw new Error("addRange(): Element within the specified Range could not be added to control selection (does it have layout?)");
        }
        newControlRange.select();

        // Update the wrapped selection based on what's now in the native selection
        updateControlSelection(sel);
    }

    var getSelectionRangeAt;

    if (util.isHostMethod(testSelection, "getRangeAt")) {
        getSelectionRangeAt = function (sel, index) {
            try {
                return sel.getRangeAt(index);
            } catch (ex) {
                return null;
            }
        };
    } else if (selectionHasAnchorAndFocus) {
        getSelectionRangeAt = function (sel) {
            var doc = dom.getDocument(sel.anchorNode);
            var range = api.createRange(doc);
            range.setStart(sel.anchorNode, sel.anchorOffset);
            range.setEnd(sel.focusNode, sel.focusOffset);

            // Handle the case when the selection was selected backwards (from the end to the start in the
            // document)
            if (range.collapsed !== this.isCollapsed) {
                range.setStart(sel.focusNode, sel.focusOffset);
                range.setEnd(sel.anchorNode, sel.anchorOffset);
            }

            return range;
        };
    }

    /**
     * @constructor
     */
    function WrappedSelection(selection, docSelection, win) {
        this.nativeSelection = selection;
        this.docSelection = docSelection;
        this._ranges = [];
        this.win = win;
        this.refresh();
    }

    api.getSelection = function (win) {
        win = win || window;
        var sel = win[windowPropertyName];
        var nativeSel = getSelection(win), docSel = implementsDocSelection ? getDocSelection(win) : null;
        if (sel) {
            sel.nativeSelection = nativeSel;
            sel.docSelection = docSel;
            sel.refresh(win);
        } else {
            sel = new WrappedSelection(nativeSel, docSel, win);
            win[windowPropertyName] = sel;
        }
        return sel;
    };

    api.getSelectionWithoutRefersh = function (win) {
        win = win || window;
        var sel = win[windowPropertyName];
        var nativeSel = getSelection(win), docSel = implementsDocSelection ? getDocSelection(win) : null;
        if (sel) {
            sel.nativeSelection = nativeSel;
            sel.docSelection = docSel;
        } else {
            sel = new WrappedSelection(nativeSel, docSel, win);
            win[windowPropertyName] = sel;
        }
        return sel;
    };

    api.getIframeSelection = function (iframeEl) {
        return api.getSelection(dom.getIframeWindow(iframeEl));
    };

    var selProto = WrappedSelection.prototype;

    function createControlSelection(sel, ranges) {
        // Ensure that the selection becomes of type "Control"
        var doc = dom.getDocument(ranges[0].startContainer);
        var controlRange = dom.getBody(doc).createControlRange();
        for (var i = 0, el;
             i < rangeCount;
             ++i) {
            el = getSingleElementFromRange(ranges[i]);
            try {
                controlRange.add(el);
            } catch (ex) {
                throw new Error("setRanges(): Element within the one of the specified Ranges could not be added to control selection (does it have layout?)");
            }
        }
        controlRange.select();

        // Update the wrapped selection based on what's now in the native selection
        updateControlSelection(sel);
    }

    // Selecting a range
    if (!useDocumentSelection && selectionHasAnchorAndFocus && util.areHostMethods(testSelection, ["removeAllRanges", "addRange"])) {
        selProto.removeAllRanges = function () {
            this.nativeSelection.removeAllRanges();
            updateEmptySelection(this);
        };

        var addRangeBackwards = function (sel, range) {
            var doc = DomRange.getRangeDocument(range);
            var endRange = api.createRange(doc);
            endRange.collapseToPoint(range.endContainer, range.endOffset);
            sel.nativeSelection.addRange(getNativeRange(endRange));
            sel.nativeSelection.extend(range.startContainer, range.startOffset);
            sel.refresh();
        };

        if (selectionHasRangeCount) {
            selProto.addRange = function (range, backwards) {
                if (implementsControlRange && implementsDocSelection && this.docSelection.type == CONTROL) {
                    addRangeToControlSelection(this, range);
                } else {
                    if (backwards && selectionHasExtend) {
                        addRangeBackwards(this, range);
                    } else {
                        var previousRangeCount;
                        if (selectionSupportsMultipleRanges) {
                            previousRangeCount = this.rangeCount;
                        } else {
                            this.removeAllRanges();
                            previousRangeCount = 0;
                        }
                        this.nativeSelection.addRange(getNativeRange(range));

                        // Check whether adding the range was successful
                        this.rangeCount = this.nativeSelection.rangeCount;

                        if (this.rangeCount == previousRangeCount + 1) {
                            // The range was added successfully

                            // Check whether the range that we added to the selection is reflected in the last range extracted from
                            // the selection
                            if (api.config.checkSelectionRanges) {
                                var nativeRange = getSelectionRangeAt(this.nativeSelection, this.rangeCount - 1);
                                if (nativeRange && !DomRange.rangesEqual(nativeRange, range)) {
                                    // Happens in WebKit with, for example, a selection placed at the start of a text node
                                    range = new WrappedRange(nativeRange);
                                }
                            }
                            this._ranges[this.rangeCount - 1] = range;
                            updateAnchorAndFocusFromRange(this, range, selectionIsBackwards(this.nativeSelection));
                            this.isCollapsed = selectionIsCollapsed(this);
                        } else {
                            // The range was not added successfully. The simplest thing is to refresh
                            this.refresh();
                        }
                    }
                }
            };
        } else {
            selProto.addRange = function (range, backwards) {
                if (backwards && selectionHasExtend) {
                    addRangeBackwards(this, range);
                } else {
                    this.nativeSelection.addRange(getNativeRange(range));
                    this.refresh();
                }
            };
        }

        selProto.setRanges = function (ranges) {
            if (implementsControlRange && ranges.length > 1) {
                createControlSelection(this, ranges);
            } else {
                this.removeAllRanges();
                for (var i = 0, len = ranges.length;
                     i < len;
                     ++i) {
                    this.addRange(ranges[i]);
                }
            }
        };
    } else if (util.isHostMethod(testSelection, "empty") && util.isHostMethod(testRange, "select") && implementsControlRange && useDocumentSelection) {

        selProto.removeAllRanges = function () {
            // Added try/catch as fix for issue #21
            try {
                this.docSelection.empty();

                // Check for empty() not working (issue #24)
                if (this.docSelection.type != "None") {
                    // Work around failure to empty a control selection by instead selecting a TextRange and then
                    // calling empty()
                    var doc;
                    if (this.anchorNode) {
                        doc = dom.getDocument(this.anchorNode);
                    } else if (this.docSelection.type == CONTROL) {
                        var controlRange = this.docSelection.createRange();
                        if (controlRange.length) {
                            doc = dom.getDocument(controlRange.item(0)).body.createTextRange();
                        }
                    }
                    if (doc) {
                        var textRange = doc.body.createTextRange();
                        textRange.select();
                        this.docSelection.empty();
                    }
                }
            } catch (ex) {
            }
            updateEmptySelection(this);
        };

        selProto.addRange = function (range) {
            if (this.docSelection.type == CONTROL) {
                addRangeToControlSelection(this, range);
            } else {
                WrappedRange.rangeToTextRange(range).select();
                this._ranges[0] = range;
                this.rangeCount = 1;
                this.isCollapsed = this._ranges[0].collapsed;
                updateAnchorAndFocusFromRange(this, range, false);
            }
        };

        selProto.setRanges = function (ranges) {
            this.removeAllRanges();
            var rangeCount = ranges.length;
            if (rangeCount > 1) {
                createControlSelection(this, ranges);
            } else if (rangeCount) {
                this.addRange(ranges[0]);
            }
        };
    } else {
        module.fail("No means of selecting a Range or TextRange was found");
        return false;
    }

    selProto.getRangeAt = function (index) {
        if (index < 0 || index >= this.rangeCount) {
            throw new DOMException("INDEX_SIZE_ERR");
        } else {
            return this._ranges[index];
        }
    };

    var refreshSelection;

    if (useDocumentSelection) {
        refreshSelection = function (sel) {
            var range;
            if (api.isSelectionValid(sel.win)) {
                range = sel.docSelection.createRange();
            } else {
                range = dom.getBody(sel.win.document).createTextRange();
                range.collapse(true);
            }

            if (sel.docSelection.type == CONTROL) {
                updateControlSelection(sel);
            } else if (isTextRange(range)) {
                updateFromTextRange(sel, range);
            } else {
                updateEmptySelection(sel);
            }
        };
    } else if (util.isHostMethod(testSelection, "getRangeAt") && typeof testSelection.rangeCount == "number") {
        refreshSelection = function (sel) {
            if (implementsControlRange && implementsDocSelection && sel.docSelection.type == CONTROL) {
                updateControlSelection(sel);
            } else {
                sel._ranges.length = sel.rangeCount = sel.nativeSelection ? sel.nativeSelection.rangeCount : null;
                if (sel.rangeCount) {
                    for (var i = 0, len = sel.rangeCount;
                         i < len;
                         ++i) {
                        sel._ranges[i] = new api.WrappedRange(sel.nativeSelection.getRangeAt(i));
                    }
                    updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], selectionIsBackwards(sel.nativeSelection));
                    sel.isCollapsed = selectionIsCollapsed(sel);
                } else {
                    updateEmptySelection(sel);
                }
            }
        };
    } else if (selectionHasAnchorAndFocus && typeof testSelection.isCollapsed == BOOLEAN && typeof testRange.collapsed == BOOLEAN && api.features.implementsDomRange) {
        refreshSelection = function (sel) {
            var range, nativeSel = sel.nativeSelection;
            if (nativeSel.anchorNode) {
                range = getSelectionRangeAt(nativeSel, 0);
                sel._ranges = [range];
                sel.rangeCount = 1;
                updateAnchorAndFocusFromNativeSelection(sel);
                sel.isCollapsed = selectionIsCollapsed(sel);
            } else {
                updateEmptySelection(sel);
            }
        };
    } else {
        module.fail("No means of obtaining a Range or TextRange from the user's selection was found");
        return false;
    }

    selProto.refresh = function (checkForChanges) {
        var oldRanges = checkForChanges ? this._ranges.slice(0) : null;
        refreshSelection(this);
        if (checkForChanges) {
            var i = oldRanges.length;
            if (i != this._ranges.length) {
                return false;
            }
            while (i--) {
                if (!DomRange.rangesEqual(oldRanges[i], this._ranges[i])) {
                    return false;
                }
            }
            return true;
        }
    };

    // Removal of a single range
    var removeRangeManually = function (sel, range) {
        var ranges = sel.getAllRanges(), removed = false;
        sel.removeAllRanges();
        for (var i = 0, len = ranges.length;
             i < len;
             ++i) {
            if (removed || range !== ranges[i]) {
                sel.addRange(ranges[i]);
            } else {
                // According to the draft WHATWG Range spec, the same range may be added to the selection multiple
                // times. removeRange should only remove the first instance, so the following ensures only the first
                // instance is removed
                removed = true;
            }
        }
        if (!sel.rangeCount) {
            updateEmptySelection(sel);
        }
    };

    if (implementsControlRange) {
        selProto.removeRange = function (range) {
            if (this.docSelection.type == CONTROL) {
                var controlRange = this.docSelection.createRange();
                var rangeElement = getSingleElementFromRange(range);

                // Create a new ControlRange containing all the elements in the selected ControlRange minus the
                // element contained by the supplied range
                var doc = dom.getDocument(controlRange.item(0));
                var newControlRange = dom.getBody(doc).createControlRange();
                var el, removed = false;
                for (var i = 0, len = controlRange.length;
                     i < len;
                     ++i) {
                    el = controlRange.item(i);
                    if (el !== rangeElement || removed) {
                        newControlRange.add(controlRange.item(i));
                    } else {
                        removed = true;
                    }
                }
                newControlRange.select();

                // Update the wrapped selection based on what's now in the native selection
                updateControlSelection(this);
            } else {
                removeRangeManually(this, range);
            }
        };
    } else {
        selProto.removeRange = function (range) {
            removeRangeManually(this, range);
        };
    }

    // Detecting if a selection is backwards
    var selectionIsBackwards;
    if (!useDocumentSelection && selectionHasAnchorAndFocus && api.features.implementsDomRange) {
        selectionIsBackwards = function (sel) {
            var backwards = false;
            if (sel.anchorNode) {
                backwards = (dom.comparePoints(sel.anchorNode, sel.anchorOffset, sel.focusNode, sel.focusOffset) == 1);
            }
            return backwards;
        };

        selProto.isBackwards = function () {
            return selectionIsBackwards(this);
        };
    } else {
        selectionIsBackwards = selProto.isBackwards = function () {
            return false;
        };
    }

    // Selection text
    // This is conformant to the new WHATWG DOM Range draft spec but differs from WebKit and Mozilla's implementation
    selProto.toString = function () {

        var rangeTexts = [];
        for (var i = 0, len = this.rangeCount;
             i < len;
             ++i) {
            rangeTexts[i] = "" + this._ranges[i];
        }
        return rangeTexts.join("");
    };

    function assertNodeInSameDocument(sel, node) {
        if (sel.anchorNode && (dom.getDocument(sel.anchorNode) !== dom.getDocument(node))) {
            throw new DOMException("WRONG_DOCUMENT_ERR");
        }
    }

    // No current browsers conform fully to the HTML 5 draft spec for this method, so Rangy's own method is always used
    selProto.collapse = function (node, offset) {
        assertNodeInSameDocument(this, node);
        var range = api.createRange(dom.getDocument(node));
        range.collapseToPoint(node, offset);
        this.removeAllRanges();
        this.addRange(range);
        this.isCollapsed = true;
    };

    selProto.collapseToStart = function () {
        if (this.rangeCount) {
            var range = this._ranges[0];
            this.collapse(range.startContainer, range.startOffset);
        } else {
            throw new DOMException("INVALID_STATE_ERR");
        }
    };

    selProto.collapseToEnd = function () {
        if (this.rangeCount) {
            var range = this._ranges[this.rangeCount - 1];
            this.collapse(range.endContainer, range.endOffset);
        } else {
            throw new DOMException("INVALID_STATE_ERR");
        }
    };

    // The HTML 5 spec is very specific on how selectAllChildren should be implemented so the native implementation is
    // never used by Rangy.
    selProto.selectAllChildren = function (node) {
        assertNodeInSameDocument(this, node);
        var range = api.createRange(dom.getDocument(node));
        range.selectNodeContents(node);
        this.removeAllRanges();
        this.addRange(range);
    };

    selProto.deleteFromDocument = function () {
        // Sepcial behaviour required for Control selections
        if (implementsControlRange && implementsDocSelection && this.docSelection.type == CONTROL) {
            var controlRange = this.docSelection.createRange();
            var element;
            while (controlRange.length) {
                element = controlRange.item(0);
                controlRange.remove(element);
                element.parentNode.removeChild(element);
            }
            this.refresh();
        } else if (this.rangeCount) {
            var ranges = this.getAllRanges();
            this.removeAllRanges();
            for (var i = 0, len = ranges.length;
                 i < len;
                 ++i) {
                ranges[i].deleteContents();
            }
            // The HTML5 spec says nothing about what the selection should contain after calling deleteContents on each
            // range. Firefox moves the selection to where the final selected range was, so we emulate that
            this.addRange(ranges[len - 1]);
        }
    };

    // The following are non-standard extensions
    selProto.getAllRanges = function () {
        return this._ranges.slice(0);
    };

    selProto.setSingleRange = function (range) {
        this.setRanges([range]);
    };

    selProto.containsNode = function (node, allowPartial) {
        for (var i = 0, len = this._ranges.length;
             i < len;
             ++i) {
            if (this._ranges[i].containsNode(node, allowPartial)) {
                return true;
            }
        }
        return false;
    };

    selProto.toHtml = function () {
        var html = "";
        if (this.rangeCount) {
            var container = DomRange.getRangeDocument(this._ranges[0]).createElement("div");
            for (var i = 0, len = this._ranges.length;
                 i < len;
                 ++i) {
                container.appendChild(this._ranges[i].cloneContents());
            }
            html = container.innerHTML;
        }
        return html;
    };

    function inspect(sel) {
        var rangeInspects = [];
        var anchor = new DomPosition(sel.anchorNode, sel.anchorOffset);
        var focus = new DomPosition(sel.focusNode, sel.focusOffset);
        var name = (typeof sel.getName == "function") ? sel.getName() : "Selection";

        if (typeof sel.rangeCount != "undefined") {
            for (var i = 0, len = sel.rangeCount;
                 i < len;
                 ++i) {
                rangeInspects[i] = DomRange.inspect(sel.getRangeAt(i));
            }
        }
        return "[" + name + "(Ranges: " + rangeInspects.join(", ") +
            ")(anchor: " + anchor.inspect() + ", focus: " + focus.inspect() + "]";
    }

    selProto.getName = function () {
        return "WrappedSelection";
    };

    selProto.inspect = function () {
        return inspect(this);
    };

    selProto.detach = function () {
        this.win[windowPropertyName] = null;
        this.win = this.anchorNode = this.focusNode = null;
    };

    WrappedSelection.inspect = inspect;

    api.Selection = WrappedSelection;

    api.selectionPrototype = selProto;

    api.addCreateMissingNativeApiListener(function (win) {
        if (typeof win.getSelection == "undefined") {
            win.getSelection = function () {
                return api.getSelection(this);
            };
        }
        win = null;
    });
});
/*
 Base.js, version 1.1a
 Copyright 2006-2010, Dean Edwards
 License: http://www.opensource.org/licenses/mit-license.php
 */

var Base = function () {
    // dummy
};

Base.extend = function (_instance, _static) {// subclass
    var extend = Base.prototype.extend;

    // build the prototype
    Base._prototyping = true;
    var proto = new this;
    extend.call(proto, _instance);
    proto.base = function () {
        // call this method from any other method to invoke that method's ancestor
    };
    delete Base._prototyping;

    // create the wrapper for the constructor function
    //var constructor = proto.constructor.valueOf(); //-dean
    var constructor = proto.constructor;
    var klass = proto.constructor = function () {
        if (!Base._prototyping) {
            if (this._constructing || this.constructor == klass) {// instantiation
                this._constructing = true;
                constructor.apply(this, arguments);
                delete this._constructing;
            } else if (arguments[0] != null) {// casting
                return (arguments[0].extend || extend).call(arguments[0], proto);
            }
        }
    };

    // build the class interface
    klass.ancestor = this;
    klass.extend = this.extend;
    klass.forEach = this.forEach;
    klass.implement = this.implement;
    klass.prototype = proto;
    klass.toString = this.toString;
    klass.valueOf = function (type) {
        //return (type == "object") ? klass : constructor; //-dean
        return (type == "object") ? klass : constructor.valueOf();
    };
    extend.call(klass, _static);
    // class initialisation
    if (typeof klass.init == "function") {
        klass.init();
    }
    return klass;
};

Base.prototype = {
    extend : function (source, value) {
        if (arguments.length > 1) {// extending with a name/value pair
            var ancestor = this[source];
            if (ancestor && (typeof value == "function") && // overriding a method?
                // the valueOf() comparison is to avoid circular references
                (!ancestor.valueOf || ancestor.valueOf() != value.valueOf()) && /\bbase\b/.test(value)) {
                // get the underlying method
                var method = value.valueOf();
                // override
                value = function () {
                    var previous = this.base || Base.prototype.base;
                    this.base = ancestor;
                    var returnValue = method.apply(this, arguments);
                    this.base = previous;
                    return returnValue;
                };
                // point to the underlying method
                value.valueOf = function (type) {
                    return (type == "object") ? value : method;
                };
                value.toString = Base.toString;
            }
            this[source] = value;
        } else if (source) {// extending with an object literal
            var extend = Base.prototype.extend;
            // if this object has a customised extend method then use it
            if (!Base._prototyping && typeof this != "function") {
                extend = this.extend || extend;
            }
            var proto = {toSource : null};
            // do the "toString" and other methods manually
            var hidden = ["constructor", "toString", "valueOf"];
            // if we are prototyping then include the constructor
            var i = Base._prototyping ? 0 : 1;
            while (key = hidden[i++]) {
                if (source[key] != proto[key]) {
                    extend.call(this, key, source[key]);
                }
            }
            // copy each of the source object's properties to this object
            for (var key in source) {
                if (!proto[key]) {
                    extend.call(this, key, source[key]);
                }
            }
        }
        return this;
    }
};

// initialise
Base = Base.extend({
    constructor : function () {
        this.extend(arguments[0]);
    }
}, {
    ancestor : Object,
    version : "1.1",

    forEach : function (object, block, context) {
        for (var key in object) {
            if (this.prototype[key] === undefined) {
                block.call(context, object[key], key, object);
            }
        }
    },

    implement : function () {
        for (var i = 0;
             i < arguments.length;
             i++) {
            if (typeof arguments[i] == "function") {
                // if it's a function, call it
                arguments[i](this.prototype);
            } else {
                // add the interface using the extend method
                this.prototype.extend(arguments[i]);
            }
        }
        return this;
    },

    toString : function () {
        return String(this.valueOf());
    }
});
/**
 * Detect browser support for specific features
 */
wysihtml5.browser = (function () {
    var userAgent = navigator.userAgent,
        testElement = document.createElement("div"),
        // Browser sniffing is unfortunately needed since some behaviors are impossible to feature detect
        isGecko = userAgent.indexOf("Gecko") !== -1 && userAgent.indexOf("KHTML") === -1,
        isWebKit = userAgent.indexOf("AppleWebKit/") !== -1,
        isChrome = userAgent.indexOf("Chrome/") !== -1,
        isOpera = userAgent.indexOf("Opera/") !== -1;

    function detectIE() {
        var ua = window.navigator.userAgent;

        var msie = ua.indexOf('MSIE ');
        if (msie > 0) {
            // IE 10 or older => return version number
            return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
        }

        var trident = ua.indexOf('Trident/');
        if (trident > 0) {
            // IE 11 => return version number
            var rv = ua.indexOf('rv:');
            return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
        }

        var edge = ua.indexOf('Edge/');
        if (edge > 0) {
            // IE 12 => return version number
            return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
        }

        // other browser
        return false;
    }

    var isIE = detectIE();
    var isFireFox = userAgent ? (userAgent.toLowerCase().indexOf('firefox') !== -1) : 0;

    function iosVersion(userAgent) {
        return +((/ipad|iphone|ipod/.test(userAgent) && userAgent.match(/ os (\d+).+? like mac os x/)) || [, 0])[1];
    }

    function androidVersion(userAgent) {
        return +(userAgent.match(/android (\d+)/) || [, 0])[1];
    }

    return {
        // Static variable needed, publicly accessible, to be able override it in unit tests
        USER_AGENT : userAgent,

        // return true if browser is firefox
        isFireFox : isFireFox,

        // return true if browser is IE
        isIE : isIE,
        /**
         * Exclude browsers that are not capable of displaying and handling
         * contentEditable as desired:
         *    - iPhone, iPad (tested iOS 4.2.2) and Android (tested 2.2) refuse to make contentEditables focusable
         *    - IE < 8 create invalid markup and crash randomly from time to time
         *
         * @return {Boolean}
         */
        supported : function () {
            var userAgent = this.USER_AGENT.toLowerCase(),
                // Essential for making html elements editable
                hasContentEditableSupport = "contentEditable" in testElement,
                // Following methods are needed in order to interact with the contentEditable area
                hasEditingApiSupport = document.execCommand && document.queryCommandSupported && document.queryCommandState,
                // document selector apis are only supported by IE 8+, Safari 4+, Chrome and Firefox 3.5+
                hasQuerySelectorSupport = document.querySelector && document.querySelectorAll,
                // contentEditable is unusable in mobile browsers (tested iOS 4.2.2, Android 2.2, Opera Mobile, WebOS 3.05)
                isIncompatibleMobileBrowser = (this.isIos() && iosVersion(userAgent) < 5) || (this.isAndroid() && androidVersion(userAgent) < 4) || userAgent.indexOf("opera mobi") !== -1 || userAgent.indexOf("hpwos/") !== -1;
            return hasContentEditableSupport && hasEditingApiSupport && hasQuerySelectorSupport && !isIncompatibleMobileBrowser;
        },

        isTouchDevice : function () {
            return this.supportsEvent("touchmove");
        },

        isIos : function () {
            return (/ipad|iphone|ipod/i).test(this.USER_AGENT);
        },

        isAndroid : function () {
            return this.USER_AGENT.indexOf("Android") !== -1;
        },

        /**
         * Whether the browser supports sandboxed iframes
         * Currently only IE 6+ offers such feature <iframe security="restricted">
         *
         * http://msdn.microsoft.com/en-us/library/ms534622(v=vs.85).aspx
         * http://blogs.msdn.com/b/ie/archive/2008/01/18/using-frames-more-securely.aspx
         *
         * HTML5 sandboxed iframes are still buggy and their DOM is not reachable from the outside (except when using postMessage)
         */
        supportsSandboxedIframes : function () {
            return isIE;
        },

        /**
         * IE6+7 throw a mixed content warning when the src of an iframe
         * is empty/unset or about:blank
         * window.querySelector is implemented as of IE8
         */
        throwsMixedContentWarningWhenIframeSrcIsEmpty : function () {
            return !("querySelector" in document);
        },

        /**
         * Whether the caret is correctly displayed in contentEditable elements
         * Firefox sometimes shows a huge caret in the beginning after focusing
         */
        displaysCaretInEmptyContentEditableCorrectly : function () {
            return isIE;
        },

        /**
         * Opera and IE are the only browsers who offer the css value
         * in the original unit, thx to the currentStyle object
         * All other browsers provide the computed style in px via window.getComputedStyle
         */
        hasCurrentStyleProperty : function () {
            return "currentStyle" in testElement;
        },

        /**
         * Firefox on OSX navigates through history when hitting CMD + Arrow right/left
         */
        hasHistoryIssue : function () {
            return isGecko;
        },

        /**
         * Whether the browser inserts a <br> when pressing enter in a contentEditable element
         */
        insertsLineBreaksOnReturn : function () {
            return isGecko;
        },

        supportsPlaceholderAttributeOn : function (element) {
            return "placeholder" in element;
        },

        supportsEvent : function (eventName) {
            return "on" + eventName in testElement || (function () {
                    testElement.setAttribute("on" + eventName, "return;");
                    return typeof(testElement["on" + eventName]) === "function";
                })();
        },

        /**
         * Opera doesn't correctly fire focus/blur events when clicking in- and outside of iframe
         */
        supportsEventsInIframeCorrectly : function () {
            return !isOpera;
        },

        /**
         * Everything below IE9 doesn't know how to treat HTML5 tags
         *
         * @param {Object} context The document object on which to check HTML5 support
         *
         * @example
         *    wysihtml5.browser.supportsHTML5Tags(document);
         */
        supportsHTML5Tags : function (context) {
            var element = context.createElement("div"),
                html5 = "<article>foo</article>";
            element.innerHTML = html5;
            return element.innerHTML.toLowerCase() === html5;
        },

        /**
         * Checks whether a document supports a certain queryCommand
         * In particular, Opera needs a reference to a document that has a contentEditable in it's dom tree
         * in oder to report correct results
         *
         * @param {Object} doc Document object on which to check for a query command
         * @param {String} command The query command to check for
         * @return {Boolean}
         *
         * @example
         *    wysihtml5.browser.supportsCommand(document, "bold");
         */
        supportsCommand : (function () {
            // Following commands are supported but contain bugs in some browsers
            var buggyCommands = {
                // formatBlock fails with some tags (eg. <blockquote>)
                "formatBlock" : isIE,
                // When inserting unordered or ordered lists in Firefox, Chrome or Safari, the current selection or line gets
                // converted into a list (<ul><li>...</li></ul>, <ol><li>...</li></ol>)
                // IE and Opera act a bit different here as they convert the entire content of the current block element into a list
                "insertUnorderedList" : isIE || isWebKit || isFireFox,
                "insertOrderedList" : isIE || isWebKit
            };

            // Firefox throws errors for queryCommandSupported, so we have to build up our own object of supported commands
            var supported = {
                "insertHTML" : isGecko
            };

            return function (doc, command) {
                var isBuggy = buggyCommands[command];
                if (!isBuggy) {
                    // Firefox throws errors when invoking queryCommandSupported or queryCommandEnabled
                    try {
                        return doc.queryCommandSupported(command);
                    } catch (e1) {
                    }

                    try {
                        return doc.queryCommandEnabled(command);
                    } catch (e2) {
                        return !!supported[command];
                    }
                }
                return false;
            };
        })(),

        /**
         * IE: URLs starting with:
         *    www., http://, https://, ftp://, gopher://, mailto:, new:, snews:, telnet:, wasis:, file://,
         *    nntp://, newsrc:, ldap://, ldaps://, outlook:, mic:// and url:
         * will automatically be auto-linked when either the user inserts them via copy&paste or presses the
         * space bar when the caret is directly after such an url.
         * This behavior cannot easily be avoided in IE < 9 since the logic is hardcoded in the mshtml.dll
         * (related blog post on msdn
         * http://blogs.msdn.com/b/ieinternals/archive/2009/09/17/prevent-automatic-hyperlinking-in-contenteditable-html.aspx).
         */
        doesAutoLinkingInContentEditable : function () {
            return isIE;
        },

        /**
         * As stated above, IE auto links urls typed into contentEditable elements
         * Since IE9 it's possible to prevent this behavior
         */
        canDisableAutoLinking : function () {
            return this.supportsCommand(document, "AutoUrlDetect");
        },

        /**
         * IE leaves an empty paragraph in the contentEditable element after clearing it
         * Chrome/Safari sometimes an empty <div>
         */
        clearsContentEditableCorrectly : function () {
            return isGecko || isOpera || isWebKit;
        },

        /**
         * IE gives wrong results for getAttribute
         */
        supportsGetAttributeCorrectly : function () {
            var td = document.createElement("td");
            return td.getAttribute("rowspan") != "1";
        },

        /**
         * When clicking on images in IE, Opera and Firefox, they are selected, which makes it easy to interact with them.
         * Chrome and Safari both don't support this
         */
        canSelectImagesInContentEditable : function () {
            return isGecko || isIE || isOpera;
        },

        /**
         * All browsers except Safari and Chrome automatically scroll the range/caret position into view
         */
        autoScrollsToCaret : function () {
            return !isWebKit;
        },

        /**
         * Check whether the browser automatically closes tags that don't need to be opened
         */
        autoClosesUnclosedTags : function () {
            var clonedTestElement = testElement.cloneNode(false),
                returnValue,
                innerHTML;

            clonedTestElement.innerHTML = "<p><div></div>";
            innerHTML = clonedTestElement.innerHTML.toLowerCase();
            returnValue = innerHTML === "<p></p><div></div>" || innerHTML === "<p><div></div></p>";

            // Cache result by overwriting current function
            this.autoClosesUnclosedTags = function () {
                return returnValue;
            };

            return returnValue;
        },

        /**
         * Whether the browser supports the native document.getElementsByClassName which returns live NodeLists
         */
        supportsNativeGetElementsByClassName : function () {
            return String(document.getElementsByClassName).indexOf("[native code]") !== -1;
        },

        /**
         * As of now (19.04.2011) only supported by Firefox 4 and Chrome
         * See https://developer.mozilla.org/en/DOM/Selection/modify
         */
        supportsSelectionModify : function () {
            return "getSelection" in window && "modify" in window.getSelection();
        },

        /**
         * Opera needs a white space after a <br> in order to position the caret correctly
         */
        needsSpaceAfterLineBreak : function () {
            return isOpera;
        },

        /**
         * Whether the browser supports the speech api on the given element
         * See http://mikepultz.com/2011/03/accessing-google-speech-api-chrome-11/
         *
         * @example
         *    var input = document.createElement("input");
         *    if (wysihtml5.browser.supportsSpeechApiOn(input)) {
     *      // ...
     *    }
         */
        supportsSpeechApiOn : function (input) {
            var chromeVersion = userAgent.match(/Chrome\/(\d+)/) || [, 0];
            return chromeVersion[1] >= 11 && ("onwebkitspeechchange" in input || "speech" in input);
        },

        /**
         * IE9 crashes when setting a getter via Object.defineProperty on XMLHttpRequest or XDomainRequest
         * See https://connect.microsoft.com/ie/feedback/details/650112
         * or try the POC http://tifftiff.de/ie9_crash/
         */
        crashesWhenDefineProperty : function (property) {
            return isIE && (property === "XMLHttpRequest" || property === "XDomainRequest");
        },

        /**
         * IE is the only browser who fires the "focus" event not immediately when .focus() is called on an element
         */
        doesAsyncFocus : function () {
            return isIE;
        },

        /**
         * In IE it's impssible for the user and for the selection library to set the caret after an <img> when it's the lastChild in the document
         */
        hasProblemsSettingCaretAfterImg : function () {
            return isIE;
        },

        hasUndoInContextMenu : function () {
            return isGecko || isChrome || isOpera;
        },

        /**
         * Opera sometimes doesn't insert the node at the right position when range.insertNode(someNode)
         * is used (regardless if rangy or native)
         * This especially happens when the caret is positioned right after a <br> because then
         * insertNode() will insert the node right before the <br>
         */
        hasInsertNodeIssue : function () {
            return isOpera;
        },

        /**
         * IE 8+9 don't fire the focus event of the <body> when the iframe gets focused (even though the caret gets set into the <body>)
         */
        hasIframeFocusIssue : function () {
            return isIE;
        }
    };
})();
wysihtml5.lang.array = function (arr) {
    return {
        /**
         * Check whether a given object exists in an array
         *
         * @example
         *    wysihtml5.lang.array([1, 2]).contains(1);
         *    // => true
         */
        contains : function (needle) {
            if (arr.indexOf) {
                return arr.indexOf(needle) !== -1;
            } else {
                for (var i = 0, length = arr.length;
                     i < length;
                     i++) {
                    if (arr[i] === needle) {
                        return true;
                    }
                }
                return false;
            }
        },

        /**
         * Substract one array from another
         *
         * @example
         *    wysihtml5.lang.array([1, 2, 3, 4]).without([3, 4]);
         *    // => [1, 2]
         */
        without : function (arrayToSubstract) {
            arrayToSubstract = wysihtml5.lang.array(arrayToSubstract);
            var newArr = [],
                i = 0,
                length = arr.length;
            for (;
                i < length;
                i++) {
                if (!arrayToSubstract.contains(arr[i])) {
                    newArr.push(arr[i]);
                }
            }
            return newArr;
        },

        /**
         * Return a clean native array
         *
         * Following will convert a Live NodeList to a proper Array
         * @example
         *    var childNodes = wysihtml5.lang.array(document.body.childNodes).get();
         */
        get : function () {
            var i = 0,
                length = arr.length,
                newArray = [];
            for (;
                i < length;
                i++) {
                newArray.push(arr[i]);
            }
            return newArray;
        }
    };
};
wysihtml5.lang.Dispatcher = Base.extend(
    /** @scope wysihtml5.lang.Dialog.prototype */ {
        on : function (eventName, handler) {
            this.events = this.events || {};
            this.events[eventName] = this.events[eventName] || [];
            this.events[eventName].push(handler);
            return this;
        },

        off : function (eventName, handler) {
            this.events = this.events || {};
            var i = 0,
                handlers,
                newHandlers;
            if (eventName) {
                handlers = this.events[eventName] || [],
                    newHandlers = [];
                for (;
                    i < handlers.length;
                    i++) {
                    if (handlers[i] !== handler && handler) {
                        newHandlers.push(handlers[i]);
                    }
                }
                this.events[eventName] = newHandlers;
            } else {
                // Clean up all events
                this.events = {};
            }
            return this;
        },

        fire : function (eventName, payload) {
            this.events = this.events || {};
            var handlers = this.events[eventName] || [],
                i = 0;
            for (;
                i < handlers.length;
                i++) {
                handlers[i].call(this, payload);
            }
            return this;
        },

        // deprecated, use .on()
        observe : function () {
            return this.on.apply(this, arguments);
        },

        // deprecated, use .off()
        stopObserving : function () {
            return this.off.apply(this, arguments);
        }
    });
wysihtml5.lang.object = function (obj) {
    return {
        /**
         * @example
         *    wysihtml5.lang.object({ foo: 1, bar: 1 }).merge({ bar: 2, baz: 3 }).get();
         *    // => { foo: 1, bar: 2, baz: 3 }
         */
        merge : function (otherObj) {
            for (var i in otherObj) {
                obj[i] = otherObj[i];
            }
            return this;
        },

        get : function () {
            return obj;
        },

        /**
         * @example
         *    wysihtml5.lang.object({ foo: 1 }).clone();
         *    // => { foo: 1 }
         */
        clone : function () {
            var newObj = {},
                i;
            for (i in obj) {
                newObj[i] = obj[i];
            }
            return newObj;
        },

        /**
         * @example
         *    wysihtml5.lang.object([]).isArray();
         *    // => true
         */
        isArray : function () {
            return Object.prototype.toString.call(obj) === "[object Array]";
        }
    };
};
(function () {
    var WHITE_SPACE_START = /^\s+/,
        WHITE_SPACE_END = /\s+$/;
    wysihtml5.lang.string = function (str) {
        str = String(str);
        return {
            /**
             * @example
             *    wysihtml5.lang.string("   foo   ").trim();
             *    // => "foo"
             */
            trim : function () {
                return str.replace(WHITE_SPACE_START, "").replace(WHITE_SPACE_END, "");
            },

            /**
             * @example
             *    wysihtml5.lang.string("Hello #{name}").interpolate({ name: "Christopher" });
             *    // => "Hello Christopher"
             */
            interpolate : function (vars) {
                for (var i in vars) {
                    str = this.replace("#{" + i + "}").by(vars[i]);
                }
                return str;
            },

            /**
             * @example
             *    wysihtml5.lang.string("Hello Tom").replace("Tom").with("Hans");
             *    // => "Hello Hans"
             */
            replace : function (search) {
                return {
                    by : function (replace) {
                        return str.split(search).join(replace);
                    }
                };
            }
        };
    };
})();
/**
 * Find urls in descendant text nodes of an element and auto-links them
 * Inspired by http://james.padolsey.com/javascript/find-and-replace-text-with-javascript/
 *
 * @param {Element} element Container element in which to search for urls
 *
 * @example
 *    <div id="text-container">Please click here: www.google.com</div>
 *    <script>wysihtml5.dom.autoLink(document.getElementById("text-container"));</script>
 */
(function (wysihtml5) {
    var /**
         * Don't auto-link urls that are contained in the following elements:
         */
        IGNORE_URLS_IN = wysihtml5.lang.array(["CODE", "PRE", "A", "SCRIPT", "HEAD", "TITLE", "STYLE"]),
        /**
         * revision 1:
         *    /(\S+\.{1}[^\s\,\.\!]+)/g
         *
         * revision 2:
         *    /(\b(((https?|ftp):\/\/)|(www\.))[-A-Z0-9+&@#\/%?=~_|!:,.;\[\]]*[-A-Z0-9+&@#\/%=~_|])/gim
         *
         * put this in the beginning if you don't wan't to match within a word
         *    (^|[\>\(\{\[\s\>])
       */
        URL_REG_EXP = /((https?:\/\/|www\.)[^\s<]{3,})/gi,
        TRAILING_CHAR_REG_EXP = /([^\w\/\-](,?))$/i,
        MAX_DISPLAY_LENGTH = 100,
        BRACKETS = {")" : "(", "]" : "[", "}" : "{"};

    function autoLink(element) {
        if (_hasParentThatShouldBeIgnored(element)) {
            return element;
        }

        if (element === element.ownerDocument.documentElement) {
            element = element.ownerDocument.body;
        }

        return _parseNode(element);
    }

    /**
     * This is basically a rebuild of
     * the rails auto_link_urls text helper
     */
    function _convertUrlsToLinks(str) {
        return str.replace(URL_REG_EXP, function (match, url) {
            var punctuation = (url.match(TRAILING_CHAR_REG_EXP) || [])[1] || "",
                opening = BRACKETS[punctuation];
            url = url.replace(TRAILING_CHAR_REG_EXP, "");

            if (url.split(opening).length > url.split(punctuation).length) {
                url = url + punctuation;
                punctuation = "";
            }
            var realUrl = url,
                displayUrl = url;
            if (url.length > MAX_DISPLAY_LENGTH) {
                displayUrl = displayUrl.substr(0, MAX_DISPLAY_LENGTH) + "...";
            }
            // Add http prefix if necessary
            if (realUrl.substr(0, 4) === "www.") {
                realUrl = "http://" + realUrl;
            }

            return '<a href="' + realUrl + '">' + displayUrl + '</a>' + punctuation;
        });
    }

    /**
     * Creates or (if already cached) returns a temp element
     * for the given document object
     */
    function _getTempElement(context) {
        var tempElement = context._wysihtml5_tempElement;
        if (!tempElement) {
            tempElement = context._wysihtml5_tempElement = context.createElement("div");
        }
        return tempElement;
    }

    /**
     * Replaces the original text nodes with the newly auto-linked dom tree
     */
    function _wrapMatchesInNode(textNode) {
        var parentNode = textNode.parentNode,
            tempElement = _getTempElement(parentNode.ownerDocument);

        // We need to insert an empty/temporary <span /> to fix IE quirks
        // Elsewise IE would strip white space in the beginning
        tempElement.innerHTML = "<span></span>" + _convertUrlsToLinks(textNode.data);
        tempElement.removeChild(tempElement.firstChild);

        while (tempElement.firstChild) {
            // inserts tempElement.firstChild before textNode
            parentNode.insertBefore(tempElement.firstChild, textNode);
        }
        parentNode.removeChild(textNode);
    }

    function _hasParentThatShouldBeIgnored(node) {
        var nodeName;
        while (node.parentNode) {
            node = node.parentNode;
            nodeName = node.nodeName;
            if (IGNORE_URLS_IN.contains(nodeName)) {
                return true;
            } else if (!wysihtml5.util.isEditorNode(node)) {
                return false;
            }
        }
        return false;
    }

    function _parseNode(element) {
        if (IGNORE_URLS_IN.contains(element.nodeName)) {
            return;
        }

        if (element.nodeType === wysihtml5.TEXT_NODE && element.data.match(URL_REG_EXP)) {
            _wrapMatchesInNode(element);
            return;
        }

        var childNodes = wysihtml5.lang.array(element.childNodes).get(),
            childNodesLength = childNodes.length,
            i = 0;

        for (;
            i < childNodesLength;
            i++) {
            _parseNode(childNodes[i]);
        }

        return element;
    }

    wysihtml5.dom.autoLink = autoLink;

    // Reveal url reg exp to the outside
    wysihtml5.dom.autoLink.URL_REG_EXP = URL_REG_EXP;
})(wysihtml5);
(function (wysihtml5) {
    var api = wysihtml5.dom;

    api.addClass = function (element, className) {
        var classList = element.classList;
        if (classList) {
            return classList.add(className);
        }
        if (api.hasClass(element, className)) {
            return;
        }
        element.className += " " + className;
    };

    api.removeClass = function (element, className) {
        var classList = element.classList;
        if (classList) {
            return classList.remove(className);
        }

        element.className = element.className.replace(new RegExp("(^|\\s+)" + className + "(\\s+|$)"), " ");
    };

    api.hasClass = function (element, className) {
        var classList = element.classList;
        if (classList) {
            return classList.contains(className);
        }

        var elementClassName = element.className;
        return (elementClassName.length > 0 && (elementClassName == className || new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
    };
})(wysihtml5);
wysihtml5.dom.contains = (function () {
    var documentElement = document.documentElement;
    if (documentElement.contains) {
        return function (container, element) {
            if (element.nodeType !== wysihtml5.ELEMENT_NODE) {
                element = element.parentNode;
            }
            return container !== element && container.contains(element);
        };
    } else if (documentElement.compareDocumentPosition) {
        return function (container, element) {
            // https://developer.mozilla.org/en/DOM/Node.compareDocumentPosition
            return !!(container.compareDocumentPosition(element) & 16);
        };
    }
})();
/**
 * Converts an HTML fragment/element into a unordered/ordered list
 *
 * @param {Element} element The element which should be turned into a list
 * @param {String} listType The list type in which to convert the tree (either "ul" or "ol")
 * @return {Element} The created list
 *
 * @example
 *    <!-- Assume the following dom: -->
 *    <span id="pseudo-list">
 *      eminem<br>
 *      dr. dre
 *      <div>50 Cent</div>
 *    </span>
 *
 *    <script>
 *      wysihtml5.dom.convertToList(document.getElementById("pseudo-list"), "ul");
 *    </script>
 *
 *    <!-- Will result in: -->
 *    <ul>
 *      <li>eminem</li>
 *      <li>dr. dre</li>
 *      <li>50 Cent</li>
 *    </ul>
 */
wysihtml5.dom.convertToList = (function () {
    function _createListItem(doc, list, isBlockElement) {
        var listItem = doc.createElement("li");
        list.appendChild(listItem);
        if (isBlockElement) {
            return listItem;
        } else {
            var para = doc.createElement("p");
            listItem.appendChild(para);
            return para;
        }
    }

    function _createList(doc, type, listType) {
        var e = doc.createElement(type);
        if (listType && listType != "Ordered") {
            e.setAttribute("type", listType);
        }
        return e;
    }

    function convertToList(element, listType, type) {
        if (element.nodeName === "UL" || element.nodeName === "OL" || element.nodeName === "MENU") {
            // Already a list
            return element;
        }
        var doc = element.ownerDocument,
            list = _createList(doc, listType, type),
            lineBreaks = element.querySelectorAll("br"),
            lineBreaksLength = lineBreaks.length,
            childNodes,
            childNodesLength,
            childNode,
            lineBreak,
            parentNode,
            isBlockElement,
            isLineBreak,
            currentListItem,
            i;

        // First find <br> at the end of inline elements and move them behind them
        for (i = 0;
             i < lineBreaksLength;
             i++) {
            lineBreak = lineBreaks[i];
            while ((parentNode = lineBreak.parentNode) && parentNode !== element && parentNode.lastChild === lineBreak) {
                if (wysihtml5.dom.getStyle("display").from(parentNode) === "block") {
                    parentNode.removeChild(lineBreak);
                    break;
                }
                wysihtml5.dom.insert(lineBreak).after(lineBreak.parentNode);
            }
        }

        childNodes = wysihtml5.lang.array(element.childNodes).get();
        childNodesLength = childNodes.length;
        for (i = 0;
             i < childNodesLength;
             i++) {

            childNode = childNodes[i];
            isBlockElement = wysihtml5.dom.getStyle("display").from(childNode) === "block" || (childNode && childNode.querySelector && childNode.querySelector(wysihtml5.BLOCK_ELEMENTS_GROUP.join(",")));
            isLineBreak = childNode.nodeName === "BR";

            if (childNode && childNode.className == "_wysihtml5-temp-placeholder") {// ignore childNode creted by executeAndRestore
                continue;
            }

            if (isBlockElement) {
                currentListItem = _createListItem(doc, list, isBlockElement);
                currentListItem.appendChild(childNode);
                currentListItem = null;
                continue;
            }

            if (isLineBreak) {
                // Only create a new list item in the next iteration when the current one has already content,
                if (i != childNodesLength - 1) {
                    currentListItem = (currentListItem && currentListItem.firstChild) ? null : currentListItem;
                    continue;
                }
            }
            currentListItem = currentListItem || _createListItem(doc, list, isBlockElement);
            currentListItem.appendChild(childNode);
        }

        if (childNodes.length === 0) {
            _createListItem(doc, list);
        }

        element.parentNode.replaceChild(list, element);
        return list;
    }

    return convertToList;
})();
/**
 * Copy a set of attributes from one element to another
 *
 * @param {Array} attributesToCopy List of attributes which should be copied
 * @return {Object} Returns an object which offers the "from" method which can be invoked with the element where to
 *    copy the attributes from., this again returns an object which provides a method named "to" which can be invoked
 *    with the element where to copy the attributes to (see example)
 *
 * @example
 *    var textarea    = document.querySelector("textarea"),
 *        div         = document.querySelector("div[contenteditable=true]"),
 *        anotherDiv  = document.querySelector("div.preview");
 *    wysihtml5.dom.copyAttributes(["spellcheck", "value", "placeholder"]).from(textarea).to(div).andTo(anotherDiv);
 *
 */
wysihtml5.dom.copyAttributes = function (attributesToCopy) {
    return {
        from : function (elementToCopyFrom) {
            return {
                to : function (elementToCopyTo) {
                    var attribute,
                        i = 0,
                        length = attributesToCopy.length;
                    for (;
                        i < length;
                        i++) {
                        attribute = attributesToCopy[i];
                        if (typeof(elementToCopyFrom[attribute]) !== "undefined" && elementToCopyFrom[attribute] !== "") {
                            elementToCopyTo[attribute] = elementToCopyFrom[attribute];
                        }
                    }
                    return {andTo : arguments.callee};
                }
            };
        }
    };
};
/**
 * Copy a set of styles from one element to another
 * Please note that this only works properly across browsers when the element from which to copy the styles
 * is in the dom
 *
 * Interesting article on how to copy styles
 *
 * @param {Array} stylesToCopy List of styles which should be copied
 * @return {Object} Returns an object which offers the "from" method which can be invoked with the element where to
 *    copy the styles from., this again returns an object which provides a method named "to" which can be invoked
 *    with the element where to copy the styles to (see example)
 *
 * @example
 *    var textarea    = document.querySelector("textarea"),
 *        div         = document.querySelector("div[contenteditable=true]"),
 *        anotherDiv  = document.querySelector("div.preview");
 *    wysihtml5.dom.copyStyles(["overflow-y", "width", "height"]).from(textarea).to(div).andTo(anotherDiv);
 *
 */
(function (dom) {

    /**
     * Mozilla, WebKit and Opera recalculate the computed width when box-sizing: boder-box; is set
     * So if an element has "width: 200px; -moz-box-sizing: border-box; border: 1px;" then
     * its computed css width will be 198px
     *
     * See https://bugzilla.mozilla.org/show_bug.cgi?id=520992
     */
    var BOX_SIZING_PROPERTIES = ["-webkit-box-sizing", "-moz-box-sizing", "-ms-box-sizing", "box-sizing"];

    var shouldIgnoreBoxSizingBorderBox = function (element) {
        if (hasBoxSizingBorderBox(element)) {
            return parseInt(dom.getStyle("width").from(element), 10) < element.offsetWidth;
        }
        return false;
    };

    var hasBoxSizingBorderBox = function (element) {
        var i = 0,
            length = BOX_SIZING_PROPERTIES.length;
        for (;
            i < length;
            i++) {
            if (dom.getStyle(BOX_SIZING_PROPERTIES[i]).from(element) === "border-box") {
                return BOX_SIZING_PROPERTIES[i];
            }
        }
    };

    dom.copyStyles = function (stylesToCopy) {
        return {
            from : function (element) {
                if (shouldIgnoreBoxSizingBorderBox(element)) {
                    stylesToCopy = wysihtml5.lang.array(stylesToCopy).without(BOX_SIZING_PROPERTIES);
                }

                var cssText = "",
                    length = stylesToCopy.length,
                    i = 0,
                    property;
                for (;
                    i < length;
                    i++) {
                    property = stylesToCopy[i];
                    cssText += property + ":" + dom.getStyle(property).from(element) + ";";
                }

                return {
                    to : function (element) {
                        dom.setStyles(cssText).on(element);
                        return {andTo : arguments.callee};
                    }
                };
            }
        };
    };
})(wysihtml5.dom);
/**
 * Event Delegation
 *
 * @example
 *    wysihtml5.dom.delegate(document.body, "a", "click", function() {
 *      // foo
 *    });
 */
(function (wysihtml5) {

    wysihtml5.dom.delegate = function (container, selector, eventName, handler) {
        return wysihtml5.dom.observe(container, eventName, function (event) {
            var target = event.target,
                match = wysihtml5.lang.array(container.querySelectorAll(selector));

            while (target && target !== container) {
                if (match.contains(target)) {
                    handler.call(target, event);
                    break;
                }
                target = target.parentNode;
            }
        });
    };
})(wysihtml5);
/**
 * Returns the given html wrapped in a div element
 *
 * Fixing IE's inability to treat unknown elements (HTML5 section, article, ...) correctly
 * when inserted via innerHTML
 *
 * @param {String} html The html which should be wrapped in a dom element
 * @param {Obejct} [context] Document object of the context the html belongs to
 *
 * @example
 *    wysihtml5.dom.getAsDom("<article>foo</article>");
 */
wysihtml5.dom.getAsDom = (function () {

    var _innerHTMLShiv = function (html, context) {
        var tempElement = context.createElement("div");
        tempElement.style.display = "none";
        context.body.appendChild(tempElement);
        // IE throws an exception when trying to insert <frameset></frameset> via innerHTML
        try {
            tempElement.innerHTML = html;
        } catch (e) {
        }
        context.body.removeChild(tempElement);
        return tempElement;
    };

    /**
     * Make sure IE supports HTML5 tags, which is accomplished by simply creating one instance of each element
     */
    var _ensureHTML5Compatibility = function (context) {
        if (context._wysihtml5_supportsHTML5Tags) {
            return;
        }
        for (var i = 0, length = HTML5_ELEMENTS.length;
             i < length;
             i++) {
            context.createElement(HTML5_ELEMENTS[i]);
        }
        context._wysihtml5_supportsHTML5Tags = true;
    };

    /**
     * List of html5 tags
     * taken from http://simon.html5.org/html5-elements
     */
    var HTML5_ELEMENTS = [
        "abbr", "article", "aside", "audio", "bdi", "canvas", "command", "datalist", "details", "figcaption",
        "figure", "footer", "header", "hgroup", "keygen", "mark", "meter", "nav", "output", "progress",
        "rp", "rt", "ruby", "svg", "section", "source", "summary", "time", "track", "video", "wbr"
    ];

    return function (html, context) {
        context = context || document;
        var tempElement;
        if (typeof(html) === "object" && html.nodeType) {
            tempElement = context.createElement("div");
            tempElement.appendChild(html);
        } else if (wysihtml5.browser.supportsHTML5Tags(context)) {
            tempElement = context.createElement("div");
            tempElement.innerHTML = html;
        } else {
            _ensureHTML5Compatibility(context);
            tempElement = _innerHTMLShiv(html, context);
        }
        tempElement.classList.add("wysihtml5-editor");
        return tempElement;
    };
})();
/**
 * Walks the dom tree from the given node up until it finds a match
 * Designed for optimal performance.
 *
 * @param {Element} node The from which to check the parent nodes
 * @param {Object} matchingSet Object to match against (possible properties: nodeName, className, classRegExp)
 * @param {Number} [levels] How many parents should the function check up from the current node (defaults to 50)
 * @return {null|Element} Returns the first element that matched the desiredNodeName(s)
 * @example
 *    var listElement = wysihtml5.dom.getParentElement(document.querySelector("li"), { nodeName: ["MENU", "UL", "OL"] });
 *    // ... or ...
 *    var unorderedListElement = wysihtml5.dom.getParentElement(document.querySelector("li"), { nodeName: "UL" });
 *    // ... or ...
 *    var coloredElement = wysihtml5.dom.getParentElement(myTextNode, { nodeName: "SPAN", className: "wysiwyg-color-red", classRegExp: /wysiwyg-color-[a-z]/g });
 */
wysihtml5.dom.getParentElement = (function () {

    function _isSameNodeName(nodeName, desiredNodeNames) {
        if (!desiredNodeNames || !desiredNodeNames.length) {
            return true;
        }

        if (typeof(desiredNodeNames) === "string") {
            return nodeName === desiredNodeNames;
        } else {
            return wysihtml5.lang.array(desiredNodeNames).contains(nodeName);
        }
    }

    function _isElement(node) {
        return node.nodeType === wysihtml5.ELEMENT_NODE;
    }

    function _hasClassName(element, className, classRegExp) {
        var classNames = (element.className || "").match(classRegExp) || [];
        if (!className) {
            return !!classNames.length;
        }
        return classNames[classNames.length - 1] === className;
    }

    function _hasAttributes(el, attributes) {
        if (el.nodeType == wysihtml5.TEXT_NODE || el.nodeType == 9) {
            return false;
        }
        var st = el.getAttribute("style");
        if (!st) {
            return false;
        }
        for (var attribute in attributes) {
            if (el.style.getPropertyValue(attribute)) {
                if (attributes[attribute] != null && attributes[attribute] == el.style.getPropertyValue(attribute)) {
                    return true;
                } else if (attributes[attribute] == null) {
                    return true;
                }
            }
        }
        return false;
    }

    function _getParentElementWithNodeName(node, nodeName, levels) {
        while (levels-- && node) {
            if (_isSameNodeName(node.nodeName, nodeName)) {
                return node;
            }
            if (!wysihtml5.util.isEditorNode(node.parentNode)) {
                node = node.parentNode;
            } else {
                break;
            }
        }
        return null;
    }

    function _getParentElementWithNodeNameAndClassName(node, nodeName, className, classRegExp, levels) {
        while (levels-- && node) {
            if (_isElement(node) && _isSameNodeName(node.nodeName, nodeName) && _hasClassName(node, className, classRegExp)) {
                return node;
            }
            if (!wysihtml5.util.isEditorNode(node.parentNode)) {
                node = node.parentNode;
            } else {
                break;
            }
        }
        return null;
    }

    function _getParentElementWithNodeNameAndAttribute(node, nodeName, attributes, levels) {
        while (levels-- && node) {
            if (_isElement(node) && _isSameNodeName(node.nodeName, nodeName) && _hasAttributes(node, attributes)) {
                return node;
            }
            if (!wysihtml5.util.isEditorNode(node.parentNode)) {
                node = node.parentNode;
            } else {
                break;
            }
        }
        return null;
    }

    return function (node, matchingSet, levels) {
        levels = levels || 50; // Go max 50 nodes upwards from current node
        if (matchingSet.attributes) {
            return _getParentElementWithNodeNameAndAttribute(
                node, matchingSet.nodeName, matchingSet.attributes, levels
            );
        } else if (matchingSet.className || matchingSet.classRegExp) {
            return _getParentElementWithNodeNameAndClassName(
                node, matchingSet.nodeName, matchingSet.className, matchingSet.classRegExp, levels
            );
        } else {
            return _getParentElementWithNodeName(
                node, matchingSet.nodeName, levels
            );
        }
    };
})();
/**
 * Get element's style for a specific css property
 *
 * @param {Element} element The element on which to retrieve the style
 * @param {String} property The CSS property to retrieve ("float", "display", "text-align", ...)
 *
 * @example
 *    wysihtml5.dom.getStyle("display").from(document.body);
 *    // => "block"
 */
wysihtml5.dom.getStyle = (function () {
    var stylePropertyMapping = {
            "float" : ("styleFloat" in document.createElement("div").style) ? "styleFloat" : "cssFloat"
        },
        REG_EXP_CAMELIZE = /\-[a-z]/g;

    function camelize(str) {
        return str.replace(REG_EXP_CAMELIZE, function (match) {
            return match.charAt(1).toUpperCase();
        });
    }

    return function (property) {
        return {
            from : function (element) {
                if (element.nodeType !== wysihtml5.ELEMENT_NODE) {
                    return;
                }

                var doc = element.ownerDocument,
                    camelizedProperty = stylePropertyMapping[property] || camelize(property),
                    style = element.style,
                    currentStyle = element.currentStyle,
                    styleValue = style[camelizedProperty];
                if (styleValue) {
                    return styleValue;
                }

                // currentStyle is no standard and only supported by Opera and IE but it has one important advantage over the standard-compliant
                // window.getComputedStyle, since it returns css property values in their original unit:
                // If you set an elements width to "50%", window.getComputedStyle will give you it's current width in px while currentStyle
                // gives you the original "50%".
                // Opera supports both, currentStyle and window.getComputedStyle, that's why checking for currentStyle should have higher prio
                if (currentStyle) {
                    try {
                        return currentStyle[camelizedProperty];
                    } catch (e) {
                        //ie will occasionally fail for unknown reasons. swallowing exception
                    }
                }

                var win = doc.defaultView || doc.parentWindow,
                    needsOverflowReset = (property === "height" || property === "width") && element.nodeName === "TEXTAREA",
                    originalOverflow,
                    returnValue;

                if (win.getComputedStyle) {
                    // Chrome and Safari both calculate a wrong width and height for textareas when they have scroll bars
                    // therfore we remove and restore the scrollbar and calculate the value in between
                    if (needsOverflowReset) {
                        originalOverflow = style.overflow;
                        style.overflow = "hidden";
                    }
                    returnValue = win.getComputedStyle(element, null).getPropertyValue(property);
                    if (needsOverflowReset) {
                        style.overflow = originalOverflow || "";
                    }
                    return returnValue;
                }
            }
        };
    };
})();
/**
 * High performant way to check whether an element with a specific tag name is in the given document
 * Optimized for being heavily executed
 * Unleashes the power of live node lists
 *
 * @param {Object} doc The document object of the context where to check
 * @param {String} tagName Upper cased tag name
 * @example
 *    wysihtml5.dom.hasElementWithTagName(document, "IMG");
 */
wysihtml5.dom.hasElementWithTagName = (function () {
    var LIVE_CACHE = {},
        DOCUMENT_IDENTIFIER = 1;

    function _getDocumentIdentifier(doc) {
        return doc._wysihtml5_identifier || (doc._wysihtml5_identifier = DOCUMENT_IDENTIFIER++);
    }

    return function (doc, tagName) {
        var key = _getDocumentIdentifier(doc) + ":" + tagName,
            cacheEntry = LIVE_CACHE[key];
        if (!cacheEntry) {
            cacheEntry = LIVE_CACHE[key] = doc.getElementsByTagName(tagName);
        }

        return cacheEntry.length > 0;
    };
})();
/**
 * High performant way to check whether an element with a specific class name is in the given document
 * Optimized for being heavily executed
 * Unleashes the power of live node lists
 *
 * @param {Object} doc The document object of the context where to check
 * @param {String} tagName Upper cased tag name
 * @example
 *    wysihtml5.dom.hasElementWithClassName(document, "foobar");
 */
(function (wysihtml5) {
    var LIVE_CACHE = {},
        DOCUMENT_IDENTIFIER = 1;

    function _getDocumentIdentifier(doc) {
        return doc._wysihtml5_identifier || (doc._wysihtml5_identifier = DOCUMENT_IDENTIFIER++);
    }

    wysihtml5.dom.hasElementWithClassName = function (doc, className) {
        // getElementsByClassName is not supported by IE<9
        // but is sometimes mocked via library code (which then doesn't return live node lists)
        if (!wysihtml5.browser.supportsNativeGetElementsByClassName()) {
            return !!doc.querySelector("." + className);
        }

        var key = _getDocumentIdentifier(doc) + ":" + className,
            cacheEntry = LIVE_CACHE[key];
        if (!cacheEntry) {
            cacheEntry = LIVE_CACHE[key] = doc.getElementsByClassName(className);
        }

        return cacheEntry.length > 0;
    };
})(wysihtml5);
wysihtml5.dom.insert = function (elementToInsert) {
    return {
        after : function (element) {
            element.parentNode.insertBefore(elementToInsert, element.nextSibling ? element.nextSibling : null);
        },

        before : function (element) {
            element.parentNode.insertBefore(elementToInsert, element);
        },

        into : function (element) {
            element.appendChild(elementToInsert);
        }
    };
};
wysihtml5.dom.insertCSS = function (rules) {
    rules = rules.join("\n");

    return {
        into : function (doc) {
            var styleElement = doc.createElement("style");
            styleElement.type = "text/css";

            if (styleElement.styleSheet) {
                styleElement.styleSheet.cssText = rules;
            } else {
                styleElement.appendChild(doc.createTextNode(rules));
            }

            var link = doc.querySelector("head link");
            if (link) {
                link.parentNode.insertBefore(styleElement, link);
                return;
            } else {
                var head = doc.querySelector("head");
                if (head) {
                    head.appendChild(styleElement);
                }
            }
        }
    };
};
/**
 * Method to set dom events
 *
 * @example
 *    wysihtml5.dom.observe(iframe.contentWindow.document.body, ["focus", "blur"], function() { ... });
 */
wysihtml5.dom.observe = function (element, eventNames, handler) {
    eventNames = typeof(eventNames) === "string" ? [eventNames] : eventNames;

    var handlerWrapper,
        eventName,
        i = 0,
        length = eventNames.length;

    for (;
        i < length;
        i++) {
        eventName = eventNames[i];
        if (element.addEventListener) {
            element.addEventListener(eventName, handler, false);
        } else {
            handlerWrapper = function (event) {
                if (!("target" in event)) {
                    event.target = event.srcElement;
                }
                event.preventDefault = event.preventDefault || function () {
                        this.returnValue = false;
                    };
                event.stopPropagation = event.stopPropagation || function () {
                        this.cancelBubble = true;
                    };
                handler.call(element, event);
            };
            element.attachEvent("on" + eventName, handlerWrapper);
        }
    }

    return {
        stop : function () {
            var eventName,
                i = 0,
                length = eventNames.length;
            for (;
                i < length;
                i++) {
                eventName = eventNames[i];
                if (element.removeEventListener) {
                    element.removeEventListener(eventName, handler, false);
                } else {
                    element.detachEvent("on" + eventName, handlerWrapper);
                }
            }
        }
    };
};
/**
 * HTML Sanitizer
 * Rewrites the HTML based on given rules
 *
 * @param {Element|String} elementOrHtml HTML String to be sanitized OR element whose content should be sanitized
 * @param {Object} [rules] List of rules for rewriting the HTML, if there's no rule for an element it will
 *    be converted to a "span". Each rule is a key/value pair where key is the tag to convert, and value the
 *    desired substitution.
 * @param {Object} context Document object in which to parse the html, needed to sandbox the parsing
 *
 * @return {Element|String} Depends on the elementOrHtml parameter. When html then the sanitized html as string elsewise the element.
 *
 * @example
 *    var userHTML = '<div id="foo" onclick="alert(1);"><p><font color="red">foo</font><script>alert(1);</script></p></div>';
 *    wysihtml5.dom.parse(userHTML, {
 *      tags {
 *        p:      "div",      // Rename p tags to div tags
 *        font:   "span"      // Rename font tags to span tags
 *        div:    true,       // Keep them, also possible (same result when passing: "div" or true)
 *        script: undefined   // Remove script elements
 *      }
 *    });
 *    // => <div><div><span>foo bar</span></div></div>
 *
 *    var userHTML = '<table><tbody><tr><td>I'm a table!</td></tr></tbody></table>';
 *    wysihtml5.dom.parse(userHTML);
 *    // => '<span><span><span><span>I'm a table!</span></span></span></span>'
 *
 *    var userHTML = '<div>foobar<br>foobar</div>';
 *    wysihtml5.dom.parse(userHTML, {
 *      tags: {
 *        div: undefined,
 *        br:  true
 *      }
 *    });
 *    // => ''
 *
 *    var userHTML = '<div class="red">foo</div><div class="pink">bar</div>';
 *    wysihtml5.dom.parse(userHTML, {
 *      classes: {
 *        red:    1,
 *        green:  1
 *      },
 *      tags: {
 *        div: {
 *          rename_tag:     "p"
 *        }
 *      }
 *    });
 *    // => '<p class="red">foo</p><p>bar</p>'
 */
wysihtml5.dom.parse = (function () {

    /**
     * It's not possible to use a XMLParser/DOMParser as HTML5 is not always well-formed XML
     * new DOMParser().parseFromString('<img src="foo.gif">') will cause a parseError since the
     * node isn't closed
     *
     * Therefore we've to use the browser's ordinary HTML parser invoked by setting innerHTML.
     */
    var NODE_TYPE_MAPPING = {
            "1" : _handleElement,
            "3" : _handleText
        },
        // Rename unknown tags to this
        DEFAULT_NODE_NAME = "span",
        WHITE_SPACE_REG_EXP = /\s+/,
        defaultRules = {tags : {}, classes : {}},
        currentRules = {},
        preProcessingContent = false;

    /**
     * Iterates over all childs of the element, recreates them, appends them into a document fragment
     * which later replaces the entire body content
     */
    function parse(elementOrHtml, rules, context, cleanUp, preProcess) {
        wysihtml5.lang.object(currentRules).merge(defaultRules).merge(rules).get();

        context = context || elementOrHtml.ownerDocument || document;
        preProcessingContent = !!preProcess;
        var fragment = context.createDocumentFragment(),
            isString = typeof(elementOrHtml) === "string",
            element,
            newNode,
            firstChild;

        if (isString) {
            element = wysihtml5.dom.getAsDom(elementOrHtml, context);
            if (preProcess) {
                element.innerHTML = element.innerHTML.replace(/\r/g, "");
                element.innerHTML = element.innerHTML.replace(/\n/g, " ");
            }
            element.style.display = "none";
            context.body.appendChild(element);
        } else {
            var innerHTML = elementOrHtml.innerHTML;
            element = elementOrHtml;
            if (preProcess) {
                innerHTML = innerHTML.replace(/\r/g, "");
                innerHTML = innerHTML.replace(/\n/g, "");
            }
            element.innerHTML = innerHTML;
        }
        while (element.firstChild) {
            firstChild = element.firstChild;
            newNode = _convert(firstChild, cleanUp, "body");
            element.removeChild(firstChild);
            if (newNode) {
                fragment.appendChild(newNode);
            }
        }

        // Clear element contents
        element.innerHTML = "";

        // Insert new DOM tree
        element.appendChild(fragment);

        // Cleanup the Word To HTML Cache
        _cleanUpWordToHTMLCache();

        if (isString) {
            context.body.removeChild(element);
        }
        return isString ? wysihtml5.quirks.getCorrectInnerHTML(element) : element;
    }

    function _convert(oldNode, cleanUp, newParentNodeName) {
        var oldNodeType = oldNode.nodeType,
            oldChilds = oldNode.childNodes,
            method = NODE_TYPE_MAPPING[oldNodeType],
            i = 0,
            newNode,
            newChild;

        // Return null for #text nodes which has only whitespaces
        if (oldNodeType == 3 && !oldNode.data.trim().length && oldNode.parentNode.hasAttribute('class', 'wysihtml5-editor')) {
            return null;
        }

        newNode = method && method(oldNode, newParentNodeName);

        if (!newNode) {
            return null;
        }

        var oldChildsLength = oldChilds.length;
        for (i = 0;
             i < oldChildsLength;
             i++) {
            newChild = _convert(oldChilds[i], cleanUp, newNode.nodeName.toLowerCase());
            if (newChild) {
                newNode.appendChild(newChild);
            }
        }

        // Cleanup senseless <span> elements
        if (cleanUp && newNode.childNodes.length <= 1 && newNode.nodeName.toLowerCase() === DEFAULT_NODE_NAME && !newNode.attributes.length) {
            return newNode.firstChild;
        }

        return newNode;
    }

    function _handleElement(oldNode, newParentNodeName) {
        var rule,
            newNode,
            tagRules = currentRules.tags,
            pseudoTags = currentRules.pseudoTags || [],
            nodeName = oldNode.nodeName.toLowerCase(),
            scopeName = oldNode.scopeName,
            tableElements = ["table", "thead", "tfoot", "th", "colgroup", "col", "tbody", "tr", "td"];

        /**
         * We already parsed that element
         * ignore it! (yes, this sometimes happens in IE8 when the html is invalid)
         */
        if (oldNode._wysihtml5) {
            return null;
        }
        oldNode._wysihtml5 = 1;

        if (oldNode.className === "wysihtml5-temp") {
            return null;
        }
        var isTableElement = tableElements.indexOf(nodeName) > -1;
        if (!isTableElement && (!oldNode.textContent || !oldNode.textContent.replace(/\n/g, "")) && oldNode.outerHTML.search("<br>") == -1) { //If firstElementChild is not found and firstElement is not a blank line.
            return null;
        }

        if (oldNode.nodeName.toLowerCase() == "li" && !oldNode.textContent.trim()) {
            return null;
        }

        /**
         * IE is the only browser who doesn't include the namespace in the
         * nodeName, that's why we have to prepend it by ourselves
         * scopeName is a proprietary IE feature
         * read more here http://msdn.microsoft.com/en-us/library/ms534388(v=vs.85).aspx
         */
        if (scopeName && scopeName != "HTML") {
            nodeName = scopeName + ":" + nodeName;
        }

        /**
         * Repair node
         * IE is a bit bitchy when it comes to invalid nested markup which includes unclosed tags
         * A <p> doesn't need to be closed according HTML4-5 spec, we simply replace it with a <div> to preserve its content and layout
         */
        if ("outerHTML" in oldNode) {
            if (!wysihtml5.browser.autoClosesUnclosedTags() && oldNode.nodeName === "P" && oldNode.outerHTML.slice(-4).toLowerCase() !== "</p>") {
                nodeName = "div";
            }
        }

        /**
         * Check if currentNode's child is to be removed as per the tagRules
         * and if currentNode's child contains innerHTML data,
         * then assign child's HTML into currentNode's HTML, to remove the child tag
         */
        if (oldNode.hasChildNodes()) {
            var childNodeName = oldNode.firstChild.nodeName.toLowerCase();
            if (childNodeName in tagRules) {
                rule = tagRules[childNodeName];
                if ((!rule || rule.remove) && oldNode.firstChild.innerHTML) {
                    oldNode.innerHTML = oldNode.firstChild.innerHTML;
                }
            }
        }

        if (nodeName in tagRules) {
            rule = tagRules[nodeName];
            if (!rule || rule.remove) {
                return null;
            }

            rule = typeof(rule) === "string" ? {rename_tag : rule} : rule;
        } else if (oldNode.firstChild) {
            rule = {rename_tag : DEFAULT_NODE_NAME};
        } else {
            // Remove empty unknown elements
            return null;
        }

        var listTypes = ["ol", "ul", "dir", "menu"];
        if (listTypes.indexOf(nodeName) >= 0) {
            var children = oldNode.childNodes;
            for (var i = 0; i < children.length; i++) {
                var childNodeName = children[i] && children[i].nodeName.toLowerCase();
                if (childNodeName && (children[i].nodeType == 1 || children[i].nodeType == 3) && children[i].textContent && listTypes.indexOf(childNodeName) == -1 && childNodeName != "li") {
                    var liNode = document.createElement("LI");
                    oldNode.insertBefore(liNode, children[i]);
                    liNode.appendChild(children[i + 1]);
                }
            }
        }

        var listType = _isMSoListParagraphChild(oldNode);
        var validChildCount = _validChildNodeCount(oldNode);
        if (listType && validChildCount) { //Child Element should be greater than two.
            newNode = _convertWordToHTMLNode(oldNode, tagRules);
        } else {
            if (/MsoNormal/i.test(oldNode.className) || (listType && !validChildCount)) { //clean list cache if a para appears after list.
                _cleanUpWordToHTMLCache();
            }
            var renameTag = rule.rename_tag || nodeName;
            if (preProcessingContent) {
                newNode = oldNode.ownerDocument.createElement(renameTag);
            } else {
                var blockElements = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "ol", "ul"];
                var parentNode = oldNode.parentNode;
                while (newParentNodeName && newParentNodeName != "body" && pseudoTags.indexOf(newParentNodeName) > -1) {
                    parentNode = parentNode.parentNode;
                    if (wysihtml5.util.isEditorNode(parentNode)) {
                        newParentNodeName = "body";
                    } else {
                        newParentNodeName = (parentNode && parentNode.nodeName) ? parentNode.nodeName.toLowerCase() : "";
                    }
                }
                if (pseudoTags.indexOf(renameTag) == -1) {
                    //For Table elements create the same new node
                    if (isTableElement) {
                        newNode = oldNode.ownerDocument.createElement(renameTag);
                    } else if (newParentNodeName == "body" && blockElements.indexOf(renameTag) == -1) {
                        newNode = oldNode.ownerDocument.createElement("p");
                    } else if ((newParentNodeName == "ul" || newParentNodeName == "ol") && renameTag != "li" && renameTag != "ol" && renameTag != "ul") {
                        newNode = oldNode.ownerDocument.createElement("li");
                    } else if (newParentNodeName != "body" && newParentNodeName != "li" && ["p", "h1", "h2", "h3", "h4", "h5", "h6"].indexOf(renameTag) > -1) {
                        newNode = oldNode.ownerDocument.createElement("span");
                    } else if ((newParentNodeName != "body" && newParentNodeName != "ol" && newParentNodeName != "ul" && newParentNodeName != "li") && ["ol", "ul", "li"].indexOf(renameTag) > -1) {
                        newNode = oldNode.ownerDocument.createElement("span");
                    } else {
                        newNode = oldNode.ownerDocument.createElement(renameTag);
                    }
                } else {
                    newNode = oldNode.ownerDocument.createElement(renameTag);
                }
            }
            _handleAttributes(oldNode, newNode, rule);
        }

        oldNode = null;
        return newNode;
    }

    function _handleAttributes(oldNode, newNode, rule) {
        var attributes = {},                         // fresh new set of attributes to set on newNode
            setClass = rule.set_class,             // classes to set
            addClass = rule.add_class,             // add classes based on existing attributes
            setAttributes = rule.set_attributes,        // attributes to set on the current node
            checkAttributes = rule.check_attributes,      // check/convert values of attributes
            allowedClasses = currentRules.classes,
            i = 0,
            classes = [],
            newClasses = [],
            newUniqueClasses = [],
            oldClasses = [],
            classesLength,
            newClassesLength,
            currentClass,
            newClass,
            attributeName,
            newAttributeValue,
            method;

        var newNodetagRules = currentRules.tags;
        var newNodeName = newNode ? newNode.nodeName.toLowerCase() : null;
        var newNodeRules;
        if (newNodeName && (newNodeName in newNodetagRules)) {
            newNodeRules = newNodetagRules[newNodeName];
        }
        var removeAttributes = newNodeRules ? newNodeRules.remove_attributes : null; // Remove attributes from old node.

        if (removeAttributes) {
            for (var i = 0; i < removeAttributes.length; i++) {
                var attr = removeAttributes[i];
                if (attr) {
                    var attrArray = attr.split(",");
                    if (attrArray.length == 1) {
                        oldNode.removeAttribute(removeAttributes[i]);
                    } else {
                        var attr = oldNode[attrArray[0]];
                        var childAttr = attr[attrArray[1]];
                        if (childAttr) {
                            if (attrArray.length > 2 && (childAttr.indexOf(attrArray[2]) != -1)) {
                                attr.removeProperty(attrArray[1]);
                            } else if (attrArray.length <= 2) {
                                attr.removeProperty(attrArray[1]);
                            }
                        }
                    }
                }
            }
        }

        if (setAttributes) {
            attributes = wysihtml5.lang.object(setAttributes).clone();
        }

        if (checkAttributes) {
            for (attributeName in checkAttributes) {
                method = attributeCheckMethods[checkAttributes[attributeName]];
                if (!method) {
                    continue;
                }
                newAttributeValue = method(_getAttribute(oldNode, attributeName));
                if (typeof(newAttributeValue) === "string") {
                    attributes[attributeName] = newAttributeValue;
                }
            }
        }

        if (setClass) {
            classes.push(setClass);
        }

        if (addClass) {
            for (attributeName in addClass) {
                method = addClassMethods[addClass[attributeName]];
                if (!method) {
                    continue;
                }
                newClass = method(_getAttribute(oldNode, attributeName));
                if (typeof(newClass) === "string") {
                    classes.push(newClass);
                }
            }
        }

        // make sure that wysihtml5 temp class doesn't get stripped out
        allowedClasses["_wysihtml5-temp-placeholder"] = 1;
        allowedClasses["Apple-tab-span"] = 2;

        // add old classes last
        oldClasses = oldNode.getAttribute("class");
        if (oldClasses) {
            classes = classes.concat(oldClasses.split(WHITE_SPACE_REG_EXP));
        }
        classesLength = classes.length;
        for (i = 0; i < classesLength; i++) {
            currentClass = classes[i];
            if (allowedClasses[currentClass]) {
                newClasses.push(currentClass);
            }
        }

        // remove duplicate entries and preserve class specificity
        newClassesLength = newClasses.length;
        while (newClassesLength--) {
            currentClass = newClasses[newClassesLength];
            if (!wysihtml5.lang.array(newUniqueClasses).contains(currentClass)) {
                newUniqueClasses.unshift(currentClass);
            }
        }

        if (newUniqueClasses.length) {
            attributes["class"] = newUniqueClasses.join(" ");
        }

        // set attributes on newNode
        for (attributeName in attributes) {
            // Setting attributes can cause a js error in IE under certain circumstances
            // eg. on a <img> under https when it's new attribute value is non-https
            // TODO: Investigate this further and check for smarter handling
            try {
                newNode.setAttribute(attributeName, attributes[attributeName]);
            } catch (e) {
            }
        }

        // IE8 sometimes loses the width/height attributes when those are set before the "src"
        // so we make sure to set them again
        if (attributes.src) {
            if (typeof(attributes.width) !== "undefined") {
                newNode.setAttribute("width", attributes.width);
            }
            if (typeof(attributes.height) !== "undefined") {
                newNode.setAttribute("height", attributes.height);
            }
        }

        _copyStyleToNewNode(oldNode, newNode);
        _copyListTypeToNewNode(oldNode, newNode);
        _copyDataAttributeToNewNode(oldNode, newNode);
    }

    function _copyDataAttributeToNewNode(oldNode, newNode) {
        if (oldNode && newNode) {
            var dataset = oldNode.dataset;
            for (var attribute in dataset) {
                $(newNode).data(attribute, dataset[attribute]);
                $(newNode).attr('data-' + attribute, dataset[attribute]);
            }
        }
    }

    function _copyListTypeToNewNode(oldNode, newNode) {
        if (oldNode.nodeName.toLowerCase() == 'ol') {
            var listType = oldNode.getAttribute('type');
            if (listType) {
                newNode.setAttribute('type', listType);
            }
        }
    }

    function _copyStyleToNewNode(oldNode, newNode) {
        var supportedStyles = currentRules.styles;
        var computedStyles = window.getComputedStyle(oldNode),
            appliedStyles = oldNode.style;
        for (var i = 0; i < appliedStyles.length; i++) {
            var styleAttr = appliedStyles[i];
            var value = appliedStyles.getPropertyValue(styleAttr);
            if (supportedStyles.indexOf(styleAttr) >= 0) {
                if (preProcessingContent && styleAttr === "background-color" && value === "rgb(255, 255, 255)") {
                    /* Remove background color if white since its redundant as it is same as default
                    * Fixes bug CQ-4209047 */
                    continue;
                } else {
                    if (!value || !value.match(/^[.\d]+pt$/)) {
                        var value = computedStyles.getPropertyValue(styleAttr) || "";
                        /* Replace all px values to pt*/
                        var regExp = new RegExp("^([.\\d]+)px$", "g");
                        var result = regExp.exec(value);
                        if (result) {
                            var valueInPx = parseFloat(result[1]);
                            var valueInPt = "";
                            if (!isNaN(valueInPx)) {
                                valueInPt = (valueInPx * 0.75) + "pt";
                            }
                            value = value.replace(regExp, valueInPt);
                        }
                    }
                }
                newNode.style.setProperty(styleAttr, value);
            }
        }
    }

    //In firefox, node.childElementCount is childnodes count where childnodes are of element type (Node.ELEMENT_NODE == 1), it does not consider text type node as element node.
    function _validChildNodeCount(oldNode) {
        if (oldNode) {
            var childNodes = oldNode.childNodes;
            var childNode, count = 0;
            for (var i = 0; i < childNodes.length; i++) {
                childNode = childNodes[i];
                if ((childNode.nodeType == 1 || childNode.nodeType == 3) && childNode.textContent && childNode.textContent.trim()) {
                    count++;
                }
            }
            if (count >= 2) {
                return true;
            }
        }
        return false;
    }

    // Bug Fix - CQ-95130. In listing extra space is added. Removing all extra space from just before and after node of type determining
    // node of Mso list.
    function _removeExtraSpace(oldNode, typeDeterminigNode) {
        var childNodes = oldNode.childNodes;
        var childNode, i;
        if (!wysihtml5.browser.isFireFox) {
            for (i = 0; childNodes[i] != typeDeterminigNode; i++) {
                childNode = childNodes[i];
                if (childNode && childNode.textContent) {
                    childNode.textContent = childNode.textContent.trim();
                }
            }
            i++; // Just next node to List type determining node
            childNode = childNodes[i];
            if (childNode && childNode.textContent) {
                childNode.textContent = childNode.textContent.trim();
            }
        }
        return oldNode;
    }

    function _convertWordToHTMLNode(oldNode, tagRules) {
        if (oldNode) {
            /* check if its MsoListParagraph then create li and if its MsoListParagraphCxSpFirst then convert to OL or UL
             * OL or UL is decided based on first Span content
             */
            if (/MsoListParagraph/i.test(oldNode.className)) {
                var isNewContainer = _setCurrentListElement(oldNode);
                // Create LI and copy the child of old node to new LI node using rule written for parsing
                var element = oldNode.ownerDocument.createElement("li"),
                    oldFontFamily = oldNode.firstElementChild.style.fontFamily,
                    fontFamilyList = Array.from($("#textEditor_fontFamily_container coral-select-item")).map(function (item) {
                        return item.value;
                    });
                // Check if copied font-family is preset in rte-editor font list, add font-family to li element
                if (oldFontFamily != null && fontFamilyList.includes(oldFontFamily.split(",")[0])) {
                    element.style.fontFamily = oldFontFamily;
                }
                var paraElement = oldNode.ownerDocument.createElement("p");
                if (oldNode.firstChild) {
                    var newNode = null, firstChild = null;
                    firstChild = _getTextChildNode(oldNode);
                    oldNode = _removeExtraSpace(oldNode, firstChild); // Remove extra space from list.
                    firstChild = _getTextChildNode(oldNode);
                    if (firstChild) {
                        oldNode.removeChild(firstChild);
                    } // Remove the firstChild which hold the Bullet or number type
                    while (oldNode.firstChild) {
                        firstChild = oldNode.firstChild;
                        newNode = _convert(firstChild, true, "p");
                        oldNode.removeChild(firstChild);
                        if (newNode) {
                            paraElement.appendChild(newNode);
                        }
                    }
                    element.appendChild(paraElement);
                }
                if (currentListElement) {
                    currentListElement.appendChild(element);
                }

                if (isNewContainer) {
                    return currentListElement;
                }
            }
        }
        return null;
    }

    var currentListElement = null;
    var levelListMap = {}; // This map will hold the Container ( OL or UL ) for each level ( multi-level listing)
    var MS_LEVEL1 = "level1";

    function _setCurrentListElement(oldNode) {
        if (oldNode) {
            var container = _createListContainer(oldNode);
            var listProperty = _getCustomCssProperty(oldNode, "mso-list");
            listProperty = listProperty ? listProperty.split(" ") : [];
            var listLevel = listProperty && listProperty.length >= 2 ? listProperty[1] : MS_LEVEL1;
            /* Create a OL or UL in following case
             * a    if currentListElement is not found in the map ( first LI)
             * b    else if bullet or number type is changed in middle
             */
            if (levelListMap.hasOwnProperty(listLevel)) {// container is available in levelListMap
                currentListElement = levelListMap[listLevel];
            }
            if (!currentListElement || (container && (currentListElement.type != container.type || !levelListMap.hasOwnProperty(listLevel)))) { // 2nd condition is if list type change or compound list then create new container
                if (MS_LEVEL1 == listLevel) {
                    levelListMap = {};
                } // If its level 1 then rest the Map
                else if (currentListElement && currentListElement.lastElementChild) {// if next level is starting then add new container to parent List container
                    currentListElement.lastElementChild.appendChild(container);
                }
                levelListMap[listLevel] = container;
                currentListElement = container;
            }
            if (MS_LEVEL1 == listLevel) {
                return true;
            } // send true if first level container is added as it need to be added in DOM other level container will be directly added to parent list container
        }
        return false;
    }

    function _cleanUpWordToHTMLCache() {
        levelListMap = {};
        currentListElement = null;
    }

    function _createListContainer(oldNode) {
        var element = null;
        if (oldNode) {
            if (/MsoListParagraph/i.test(oldNode.className)) {
                var textNode = _getTextChildNode(oldNode);
                if (textNode) {
                    var textContent = textNode.textContent ? textNode.textContent.trim() : "";
                    var splitArray = textContent.split(".");
                    if ((splitArray.length - 2) >= 0) {
                        textContent = splitArray[splitArray.length - 2];
                    }
                    var type = textContent ? _getListContainerType(textContent) : null;
                    if (type) {// Check type of content in firstSpan ( which contains bullet or number type)
                        var elementName = /disc|circle|square/.test(type) ? "ul" : "ol";
                        element = oldNode.ownerDocument.createElement(elementName);
                        element.type = type;
                    } else {// if type is not recognized then created UL with type disc
                        element = oldNode.ownerDocument.createElement("ul");
                        element.type = "disc";
                    }
                }
            }
        }
        return element;
    }

    function checkForAlphabetList(textContent, currentListElement) {
        if (currentListElement && (currentListElement.type == "a" || currentListElement.type == "A")) {
            var alphabet = "abcdefghijklmnopqrstuvwxyz";
            var characterInAlphabetSet = alphabet.charAt(currentListElement.childElementCount);
            if (currentListElement.type == "A") {
                characterInAlphabetSet = alphabet.toUpperCase().charAt(currentListElement.childElementCount);
            }
            if (textContent == characterInAlphabetSet) {
                return currentListElement.type;
            }
        }
        if (currentListElement && currentListElement.parentElement && currentListElement.parentElement.parentElement) {
            return checkForAlphabetList(textContent, currentListElement.parentElement.parentElement);
        }
    }

    function checkForNumericList(textContent, currentListElement) {
        if (currentListElement && (currentListElement.type == "1")) {
            var childElements = currentListElement.childElementCount;
            var decimalValue = parseInt(textContent);
            if (childElements + 1 == decimalValue) {
                return currentListElement.type;
            }
        }
        if (currentListElement && currentListElement.parentElement && currentListElement.parentElement.parentElement) {
            return checkForNumericList(textContent, currentListElement.parentElement.parentElement);
        }
    }

    function checkForRomanList(textContent, currentListElement) {
        if (currentListElement && (currentListElement.type == "i" || currentListElement.type == "I")) {
            var childElements = currentListElement.childElementCount;
            var romanValue = _getRomanToDecimal(textContent);

            if (childElements + 1 == romanValue) {
                if ((textContent[0].toUpperCase() == textContent[0]) && (currentListElement.type == "I")) {
                    return currentListElement.type;
                } else if ((textContent[0].toLowerCase() == textContent[0]) && (currentListElement.type == "i")) {
                    return currentListElement.type;
                }
            }
        }
        if (currentListElement && currentListElement.parentElement && currentListElement.parentElement.parentElement) {
            return checkForRomanList(textContent, currentListElement.parentElement.parentElement);
        }

    }

    function _getIntegerValue(romanChar) {
        var romArr = ["i", "v", "x", "l", "c", "d", "m"];
        var intArr = [1, 5, 10, 50, 100, 500, 1000];
        return intArr[romArr.indexOf(romanChar)];
    }

    function _getRomanToDecimal(str) {
        var res = 0, romanFirstVal, romanSecondVal;
        var lowerRomanTypeReg = /^m{0,4}(cm|cd|d?c{0,3})(xc|xl|l?x{0,3})(ix|iv|v?i{0,3})$/;
        if (str.toLowerCase().match(lowerRomanTypeReg)) {
            for (var i = 0; i < str.length; i++) {
                romanFirstVal = _getIntegerValue(str[i].toLowerCase());
                if (i + 1 < str.length) {
                    romanSecondVal = _getIntegerValue(str[i + 1].toLowerCase());
                    if (romanFirstVal >= romanSecondVal) {
                        res = res + romanFirstVal;
                    } else {
                        res = res + romanSecondVal - romanFirstVal;
                        i++;
                    }
                } else {
                    res = res + romanFirstVal;
                    i++;
                }
            }
            return res;
        }
    }

    function _getListContainerType(textContentStr) {
        var decimalTypeReg = /\d+/,
            lowerRomanTypeReg = /^m{0,4}(cm|cd|d?c{0,3})(xc|xl|l?x{0,3})(ix|iv|v?i{0,3})$/,
            upperRomanTypeReg = /^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/,
            lowerAlphaTypeReg = /^[a-z]+$/,
            upperAlphaTypeReg = /^[A-Z]+$/;
        var discTypeReg = /[l\u00B7\u2002]/,
            circleTypeReg = /[\u006F\u00D8]/,
            squareTypeReg = /[\u006E\u25C6\u00A7]/;

        var validAlphabet = false, validRoman = false, validInteger = false;
        if (textContentStr) {
            if (textContentStr.toLowerCase().match(lowerRomanTypeReg)) {
                validRoman = true;
            }
            if (textContentStr.toLowerCase().match(lowerAlphaTypeReg)) {
                validAlphabet = true;
            }
            if (textContentStr.match(decimalTypeReg)) {
                validInteger = true;
            }
        }

        var romanList = validRoman ? checkForRomanList(textContentStr, currentListElement) : null;
        if (romanList) {
            return romanList;
        }

        var textContent = textContentStr.substr(0, 1);
        var alphaList = validAlphabet ? checkForAlphabetList(textContent, currentListElement) : null;
        if (alphaList) {
            return alphaList;
        }

        var numericList = validInteger ? checkForNumericList(textContentStr, currentListElement) : null;
        if (numericList) {
            return numericList;
        }

        if (textContentStr && (textContentStr == "a" || textContentStr == "A" || textContentStr == "i" || textContentStr == "I" || textContentStr == "1")) {
            return textContentStr;
        } else if (textContent.match(discTypeReg)) {
            return "disc";
        } else if (textContent.match(circleTypeReg)) {
            return "circle";
        } else if (textContent.match(squareTypeReg)) {
            return "square";
        }
        return null;
    }

    // Action on  MSO List node which first text node has list type information.
    function _getTextChildNode(oldNode) {
        if (oldNode) {
            var childNodes = oldNode.childNodes;
            var textContent, childNode;
            for (var i = 0; i < childNodes.length; i++) {
                childNode = childNodes[i];
                textContent = childNode.textContent ? childNode.textContent.trim() : "";
                if (childNode && (childNode.nodeType == 3 || childNode.nodeType == 1) && textContent) {
                    return childNode;
                }
            }
        }
    }

    function _isMSoListParagraphChild(oldNode) {
        // Since each and very element is passed why parser check if any element is part of MsoListParagraph if so ignore it as its already handle via creating LI
        if (oldNode) {
            if (/MsoListParagraph/i.test(oldNode.className)) {
                return true;
            }
        }
        return false;
    }

    function _getCustomCssProperty(element, propertyName) {
        if (element) {
            var style = element.getAttribute("style");
            var entries = style.split(";");

            for (var i = 0;
                 i < entries.length;
                 i++) {
                var entry = entries[i].split(":");
                if (entry[0] == propertyName) {
                    return entry[1];
                }
            }
        }
        return null;
    }

    /**
     * IE gives wrong results for hasAttribute/getAttribute, for example:
     *    var td = document.createElement("td");
     *    td.getAttribute("rowspan"); // => "1" in IE
     *
     * Therefore we have to check the element's outerHTML for the attribute
     */
    var HAS_GET_ATTRIBUTE_BUG = !wysihtml5.browser.supportsGetAttributeCorrectly();

    function _getAttribute(node, attributeName) {
        attributeName = attributeName.toLowerCase();
        var nodeName = node.nodeName;
        if (nodeName == "IMG" && attributeName == "src" && _isLoadedImage(node) === true) {
            // Get 'src' attribute value via object property since this will always contain the
            // full absolute url (http://...)
            // this fixes a very annoying bug in firefox (ver 3.6 & 4) and IE 8 where images copied from the same host
            // will have relative paths, which the sanitizer strips out (see attributeCheckMethods.url)
            return node.src;
        } else if (HAS_GET_ATTRIBUTE_BUG && "outerHTML" in node) {
            // Don't trust getAttribute/hasAttribute in IE 6-8, instead check the element's outerHTML
            var outerHTML = node.outerHTML.toLowerCase(),
                // TODO: This might not work for attributes without value: <input disabled>
                hasAttribute = outerHTML.indexOf(" " + attributeName + "=") != -1;

            return hasAttribute ? node.getAttribute(attributeName) : null;
        } else {
            return node.getAttribute(attributeName);
        }
    }

    /**
     * Check whether the given node is a proper loaded image
     * FIXME: Returns undefined when unknown (Chrome, Safari)
     */
    function _isLoadedImage(node) {
        try {
            return node.complete && !node.mozMatchesSelector(":-moz-broken");
        } catch (e) {
            if (node.complete && node.readyState === "complete") {
                return true;
            }
        }
    }

    function _handleText(oldNode) {
        return oldNode.ownerDocument.createTextNode(oldNode.data);
    }

    // ------------ attribute checks ------------ \\
    var attributeCheckMethods = {
        any : (function () {
            return function (attributeValue) {
                return attributeValue;
            };
        })(),

        url : (function () {
            var REG_EXP = /^https?:\/\//i;
            return function (attributeValue) {
                if (!attributeValue || !attributeValue.match(REG_EXP)) {
                    return null;
                }
                return attributeValue.replace(REG_EXP, function (match) {
                    return match.toLowerCase();
                });
            };
        })(),

        src : (function () {
            var REG_EXP = /^(\/|https?:\/\/)/i;
            return function (attributeValue) {
                if (!attributeValue || !attributeValue.match(REG_EXP)) {
                    return null;
                }
                return attributeValue.replace(REG_EXP, function (match) {
                    return match.toLowerCase();
                });
            };
        })(),

        href : (function () {
            var REG_EXP = /^(\/|https?:\/\/|mailto:)/i;
            return function (attributeValue) {
                if (!attributeValue || !attributeValue.match(REG_EXP)) {
                    return null;
                }
                return attributeValue.replace(REG_EXP, function (match) {
                    return match.toLowerCase();
                });
            };
        })(),

        alt : (function () {
            var REG_EXP = /[^ a-z0-9_\-]/gi;
            return function (attributeValue) {
                if (!attributeValue) {
                    return "";
                }
                return attributeValue.replace(REG_EXP, "");
            };
        })(),

        numbers : (function () {
            var REG_EXP = /\D/g;
            return function (attributeValue) {
                attributeValue = (attributeValue || "").replace(REG_EXP, "");
                return attributeValue || null;
            };
        })()
    };

    // ------------ class converter (converts an html attribute to a class name) ------------ \\
    var addClassMethods = {
        align_img : (function () {
            var mapping = {
                left : "wysiwyg-float-left",
                right : "wysiwyg-float-right"
            };
            return function (attributeValue) {
                return mapping[String(attributeValue).toLowerCase()];
            };
        })(),

        align_text : (function () {
            var mapping = {
                left : "wysiwyg-text-align-left",
                right : "wysiwyg-text-align-right",
                center : "wysiwyg-text-align-center",
                justify : "wysiwyg-text-align-justify"
            };
            return function (attributeValue) {
                return mapping[String(attributeValue).toLowerCase()];
            };
        })(),

        clear_br : (function () {
            var mapping = {
                left : "wysiwyg-clear-left",
                right : "wysiwyg-clear-right",
                both : "wysiwyg-clear-both",
                all : "wysiwyg-clear-both"
            };
            return function (attributeValue) {
                return mapping[String(attributeValue).toLowerCase()];
            };
        })(),

        size_font : (function () {
            var mapping = {
                "1" : "wysiwyg-font-size-xx-small",
                "2" : "wysiwyg-font-size-small",
                "3" : "wysiwyg-font-size-medium",
                "4" : "wysiwyg-font-size-large",
                "5" : "wysiwyg-font-size-x-large",
                "6" : "wysiwyg-font-size-xx-large",
                "7" : "wysiwyg-font-size-xx-large",
                "-" : "wysiwyg-font-size-smaller",
                "+" : "wysiwyg-font-size-larger"
            };
            return function (attributeValue) {
                return mapping[String(attributeValue).charAt(0)];
            };
        })()
    };

    return parse;
})();
/**
 * Checks for empty text node childs and removes them
 *
 * @param {Element} node The element in which to cleanup
 * @example
 *    wysihtml5.dom.removeEmptyTextNodes(element);
 */
wysihtml5.dom.removeEmptyTextNodes = function (node) {
    var childNode,
        childNodes = wysihtml5.lang.array(node.childNodes).get(),
        childNodesLength = childNodes.length,
        i = 0;
    for (;
        i < childNodesLength;
        i++) {
        childNode = childNodes[i];
        if (childNode.nodeType === wysihtml5.TEXT_NODE && childNode.data === "") {
            childNode.parentNode.removeChild(childNode);
        }
    }
};
/**
 * Renames an element (eg. a <div> to a <p>) and keeps its childs
 *
 * @param {Element} element The list element which should be renamed
 * @param {Element} newNodeName The desired tag name
 *
 * @example
 *    <!-- Assume the following dom: -->
 *    <ul id="list">
 *      <li>eminem</li>
 *      <li>dr. dre</li>
 *      <li>50 Cent</li>
 *    </ul>
 *
 *    <script>
 *      wysihtml5.dom.renameElement(document.getElementById("list"), "ol");
 *    </script>
 *
 *    <!-- Will result in: -->
 *    <ol>
 *      <li>eminem</li>
 *      <li>dr. dre</li>
 *      <li>50 Cent</li>
 *    </ol>
 */
wysihtml5.dom.renameElement = function (element, newNodeName) {
    var newElement = element.ownerDocument.createElement(newNodeName),
        firstChild;
    while (firstChild = element.firstChild) {
        newElement.appendChild(firstChild);
    }
    wysihtml5.dom.copyAttributes(["align", "className"]).from(element).to(newElement);
    //wysihtml5.dom.copyStyles(["line-height"]).from(element).to(newElement);
    element.parentNode.replaceChild(newElement, element);
    return newElement;
};
/**
 * Takes an element, removes it and replaces it with it's childs
 *
 * @param {Object} node The node which to replace with it's child nodes
 * @example
 *    <div id="foo">
 *      <span>hello</span>
 *    </div>
 *    <script>
 *      // Remove #foo and replace with it's children
 *      wysihtml5.dom.replaceWithChildNodes(document.getElementById("foo"));
 *    </script>
 */
wysihtml5.dom.replaceWithChildNodes = function (node) {
    if (!node.parentNode) {
        return;
    }

    if (!node.firstChild) {
        node.parentNode.removeChild(node);
        return;
    }

    var fragment = node.ownerDocument.createDocumentFragment();
    while (node.firstChild) {
        fragment.appendChild(node.firstChild);
    }
    node.parentNode.replaceChild(fragment, node);
    node = fragment = null;
};
/**
 * Unwraps an unordered/ordered list
 *
 * @param {Element} element The list element which should be unwrapped
 *
 * @example
 *    <!-- Assume the following dom: -->
 *    <ul id="list">
 *      <li>eminem</li>
 *      <li>dr. dre</li>
 *      <li>50 Cent</li>
 *    </ul>
 *
 *    <script>
 *      wysihtml5.dom.resolveList(document.getElementById("list"));
 *    </script>
 *
 *    <!-- Will result in: -->
 *    eminem<br>
 *    dr. dre<br>
 *    50 Cent<br>
 */
(function (dom) {
    function _isBlockElement(node) {
        return dom.getStyle("display").from(node) === "block";
    }

    function _isLineBreak(node) {
        return node.nodeName === "BR";
    }

    function _appendLineBreak(element) {
        var lineBreak = element.ownerDocument.createElement("br");
        element.appendChild(lineBreak);
    }

    function resolveList(list, useLineBreaks) {
        if (!list.nodeName.match(/^(MENU|UL|OL)$/)) {
            return;
        }

        var doc = list.ownerDocument,
            fragment = doc.createDocumentFragment(),
            previousSibling = list.previousElementSibling || list.previousSibling,
            firstChild,
            lastChild,
            isLastChild,
            shouldAppendLineBreak,
            paragraph,
            listItem;

        if (useLineBreaks) {
            // Insert line break if list is after a non-block element
            if (previousSibling && !_isBlockElement(previousSibling)) {
                _appendLineBreak(fragment);
            }

            while (listItem = (list.firstElementChild || list.firstChild)) {
                lastChild = listItem.lastChild;
                while (firstChild = listItem.firstChild) {
                    isLastChild = firstChild === lastChild;
                    // This needs to be done before appending it to the fragment, as it otherwise will lose style information
                    shouldAppendLineBreak = isLastChild && !_isBlockElement(firstChild) && !_isLineBreak(firstChild);
                    fragment.appendChild(firstChild);
                    if (shouldAppendLineBreak) {
                        _appendLineBreak(fragment);
                    }
                }

                listItem.parentNode.removeChild(listItem);
            }
        } else {
            while (listItem = (list.firstElementChild || list.firstChild)) {
                if (listItem.querySelector && listItem.querySelector("div, p, ul, ol, menu, blockquote, h1, h2, h3, h4, h5, h6")) {
                    while (firstChild = listItem.firstChild) {
                        fragment.appendChild(firstChild);
                    }
                } else {
                    paragraph = doc.createElement("p");
                    while (firstChild = listItem.firstChild) {
                        paragraph.appendChild(firstChild);
                    }
                    fragment.appendChild(paragraph);
                }
                listItem.parentNode.removeChild(listItem);
            }
        }

        list.parentNode.replaceChild(fragment, list);
    }

    dom.resolveList = resolveList;
})(wysihtml5.dom);
/**
 * Sandbox for executing javascript, parsing css styles and doing dom operations in a secure way
 *
 * Browser Compatibility:
 *  - Secure in MSIE 6+, but only when the user hasn't made changes to his security level "restricted"
 *  - Partially secure in other browsers (Firefox, Opera, Safari, Chrome, ...)
 *
 * Please note that this class can't benefit from the HTML5 sandbox attribute for the following reasons:
 *    - sandboxing doesn't work correctly with inlined content (src="javascript:'<html>...</html>'")
 *    - sandboxing of physical documents causes that the dom isn't accessible anymore from the outside (iframe.contentWindow, ...)
 *    - setting the "allow-same-origin" flag would fix that, but then still javascript and dom events refuse to fire
 *    - therefore the "allow-scripts" flag is needed, which then would deactivate any security, as the js executed inside the iframe
 *      can do anything as if the sandbox attribute wasn't set
 *
 * @param {Function} [readyCallback] Method that gets invoked when the sandbox is ready
 * @param {Object} [config] Optional parameters
 *
 * @example
 *    new wysihtml5.dom.Sandbox(function(sandbox) {
 *      sandbox.getWindow().document.body.innerHTML = '<img src=foo.gif onerror="alert(document.cookie)">';
 *    });
 */
(function (wysihtml5) {
    var /**
         * Default configuration
         */
        doc = document,
        /**
         * Properties to unset/protect on the window object
         */
        windowProperties = [
            "parent", "top", "opener", "frameElement", "frames",
            "localStorage", "globalStorage", "sessionStorage", "indexedDB"
        ],
        /**
         * Properties on the window object which are set to an empty function
         */
        windowProperties2 = [
            "open", "close", "openDialog", "showModalDialog",
            "alert", "confirm", "prompt",
            "openDatabase", "postMessage",
            "XMLHttpRequest", "XDomainRequest"
        ],
        /**
         * Properties to unset/protect on the document object
         */
        documentProperties = [
            "referrer",
            "write", "open", "close"
        ];

    wysihtml5.dom.Sandbox = Base.extend(
        /** @scope wysihtml5.dom.Sandbox.prototype */ {

            constructor : function (config) {
                this.config = wysihtml5.lang.object({}).merge(config).get();
                this.container = this._createContainer();
            },

            insertInto : function (element) {
                if (typeof(element) === "string") {
                    element = doc.getElementById(element);
                }

                element.appendChild(this.container);
            },

            getContainer : function () {
                return this.container;
            },

            getWindow : function () {
                this._readyError();
            },

            getDocument : function () {
                this._readyError();
            },

            destroy : function () {
                var container = this.getContainer();
                if (container && container.parentNode) {
                    container.parentNode.removeChild(container);
                }
            },

            _readyError : function () {
                throw new Error("wysihtml5.Sandbox: Sandbox container isn't loaded yet");
            },

            /**
             * Creates the sandbox container
             *
             * Some important notes:
             *  - We can't use HTML5 sandbox for now:
             *    setting it causes that the iframe's dom can't be accessed from the outside
             *    Therefore we need to set the "allow-same-origin" flag which enables accessing the iframe's dom
             *    But then there's another problem, DOM events (focus, blur, change, keypress, ...) aren't fired.
             *    In order to make this happen we need to set the "allow-scripts" flag.
             *    A combination of allow-scripts and allow-same-origin is almost the same as setting no sandbox attribute at all.
             *  - Chrome & Safari, doesn't seem to support sandboxing correctly when the iframe's html is inlined (no physical document)
             *  - IE needs to have the security="restricted" attribute set before the iframe is
             *    inserted into the dom tree
             *  - Believe it or not but in IE "security" in document.createElement("iframe") is false, even
             *    though it supports it
             *  - When an iframe has security="restricted", in IE eval() & execScript() don't work anymore
             *  - IE doesn't fire the onload event when the content is inlined in the src attribute, therefore we rely
             *    on the onreadystatechange event
             */
            _createContainer : function () {
                var container = doc.createElement("div");
                this.getWindow = function () {
                    var doc = this.getDocument();
                    return doc.defaultView || doc.parentWindow;
                };
                this.getDocument = function () {
                    return container.ownerDocument;
                };

                return container;
            },

            _getHtml : function (templateVars) {
                var stylesheets = templateVars.stylesheets,
                    html = "",
                    i = 0,
                    length;
                stylesheets = typeof(stylesheets) === "string" ? [stylesheets] : stylesheets;
                if (stylesheets) {
                    length = stylesheets.length;
                    for (;
                        i < length;
                        i++) {
                        html += '<link rel="stylesheet" href="' + stylesheets[i] + '">';
                    }
                }
                templateVars.stylesheets = html;

                return wysihtml5.lang.string(
                    '<!DOCTYPE html><html><head>' +
                    '<meta charset="#{charset}">#{stylesheets}</head>' +
                    '<body></body></html>'
                ).interpolate(templateVars);
            },

            /**
             * Method to unset/override existing variables
             * @example
             *    // Make cookie unreadable and unwritable
             *    this._unset(document, "cookie", "", true);
             */
            _unset : function (object, property, value, setter) {
                try {
                    object[property] = value;
                } catch (e) {
                }

                try {
                    object.__defineGetter__(property, function () {
                        return value;
                    });
                } catch (e) {
                }
                if (setter) {
                    try {
                        object.__defineSetter__(property, function () {
                        });
                    } catch (e) {
                    }
                }

                if (!wysihtml5.browser.crashesWhenDefineProperty(property)) {
                    try {
                        var config = {
                            get : function () {
                                return value;
                            }
                        };
                        if (setter) {
                            config.set = function () {
                            };
                        }
                        Object.defineProperty(object, property, config);
                    } catch (e) {
                    }
                }
            }
        });
})(wysihtml5);
(function () {
    var mapping = {
        "className" : "class"
    };
    wysihtml5.dom.setAttributes = function (attributes) {
        return {
            on : function (element) {
                for (var i in attributes) {
                    element.setAttribute(mapping[i] || i, attributes[i]);
                }
            }
        };
    };
})();
wysihtml5.dom.setStyles = function (styles) {
    return {
        on : function (element) {
            var style = element.style;
            if (typeof(styles) === "string") {
                style.cssText += ";" + styles;
                return;
            }
            for (var i in styles) {
                if (i === "float") {
                    style.cssFloat = styles[i];
                    style.styleFloat = styles[i];
                } else {
                    style[i] = styles[i];
                }
            }
        }
    };
};
/**
 * Simulate HTML5 placeholder attribute
 *
 * Needed since
 *    - div[contentEditable] elements don't support it
 *    - older browsers (such as IE8 and Firefox 3.6) don't support it at all
 *
 * @param {Object} parent Instance of main wysihtml5.Editor class
 * @param {Element} view Instance of wysihtml5.views.* class
 * @param {String} placeholderText
 *
 * @example
 *    wysihtml.dom.simulatePlaceholder(this, composer, "Foobar");
 */
(function (dom) {
    dom.simulatePlaceholder = function (editor, view, placeholderText) {
        var CLASS_NAME = "placeholder",
            unset = function () {
                if (view.hasPlaceholderSet()) {
                    view.clear();
                }
                view.placeholderSet = false;
                dom.removeClass(view.element, CLASS_NAME);
            },
            set = function () {
                if (view.isEmpty()) {
                    view.placeholderSet = true;
                    view.setValue(placeholderText);
                    dom.addClass(view.element, CLASS_NAME);
                }
            };

        editor
            .on("set_placeholder", set)
            .on("unset_placeholder", unset)
            .on("focus:composer", unset)
            .on("click:composer", unset)
            .on("paste:composer", unset)
            .on("blur:composer", set);

        set();
    };
})(wysihtml5.dom);
(function (dom) {
    var documentElement = document.documentElement;
    if ("textContent" in documentElement) {
        dom.setTextContent = function (element, text) {
            element.textContent = text;
        };

        dom.getTextContent = function (element) {
            return element.textContent;
        };
    } else if ("innerText" in documentElement) {
        dom.setTextContent = function (element, text) {
            element.innerText = text;
        };

        dom.getTextContent = function (element) {
            return element.innerText;
        };
    } else {
        dom.setTextContent = function (element, text) {
            element.nodeValue = text;
        };

        dom.getTextContent = function (element) {
            return element.nodeValue;
        };
    }
})(wysihtml5.dom);

/**
 * Fix most common html formatting misbehaviors of browsers implementation when inserting
 * content via copy & paste contentEditable
 *
 * @author Christopher Blum
 */
wysihtml5.quirks.cleanPastedHTML = (function () {
    // TODO: We probably need more rules here
    var defaultRules = {
        // When pasting underlined links <a> into a contentEditable, IE thinks, it has to insert <u> to keep the styling
        "a u" : wysihtml5.dom.replaceWithChildNodes
    };

    function cleanPastedHTML(elementOrHtml, rules, context) {
        rules = rules || defaultRules;
        context = context || elementOrHtml.ownerDocument || document;

        var element,
            isString = typeof(elementOrHtml) === "string",
            method,
            matches,
            matchesLength,
            i,
            j = 0;
        if (isString) {
            element = wysihtml5.dom.getAsDom(elementOrHtml, context);
        } else {
            element = elementOrHtml;
        }

        for (i in rules) {
            matches = element.querySelectorAll(i);
            method = rules[i];
            matchesLength = matches.length;
            for (;
                j < matchesLength;
                j++) {
                method(matches[j]);
            }
        }

        matches = elementOrHtml = rules = null;

        return isString ? element.innerHTML : element;
    }

    return cleanPastedHTML;
})();
/**
 * IE and Opera leave an empty paragraph in the contentEditable element after clearing it
 *
 * @param {Object} contentEditableElement The contentEditable element to observe for clearing events
 * @exaple
 *    wysihtml5.quirks.ensureProperClearing(myContentEditableElement);
 */
wysihtml5.quirks.ensureProperClearing = (function () {
    var clearIfNecessary = function () {
        var element = this;
        setTimeout(function () {
            var innerHTML = element.innerHTML.toLowerCase();
            if (innerHTML == "<p>&nbsp;</p>" ||
                innerHTML == "<p>&nbsp;</p><p>&nbsp;</p>") {
                element.innerHTML = "";
            }
        }, 0);
    };

    return function (composer) {
        wysihtml5.dom.observe(composer.element, ["cut", "keydown"], clearIfNecessary);
    };
})();
// See https://bugzilla.mozilla.org/show_bug.cgi?id=664398
//
// In Firefox this:
//      var d = document.createElement("div");
//      d.innerHTML ='<a href="~"></a>';
//      d.innerHTML;
// will result in:
//      <a href="%7E"></a>
// which is wrong
(function (wysihtml5) {
    var TILDE_ESCAPED = "%7E";
    wysihtml5.quirks.getCorrectInnerHTML = function (element) {
        var innerHTML = element.innerHTML;
        if (innerHTML.indexOf(TILDE_ESCAPED) === -1) {
            return innerHTML.trim();
        }

        var elementsWithTilde = element.querySelectorAll("[href*='~'], [src*='~']"),
            url,
            urlToSearch,
            length,
            i;
        for (i = 0, length = elementsWithTilde.length;
             i < length;
             i++) {
            url = elementsWithTilde[i].href || elementsWithTilde[i].src;
            urlToSearch = wysihtml5.lang.string(url).replace("~").by(TILDE_ESCAPED);
            innerHTML = wysihtml5.lang.string(innerHTML).replace(urlToSearch).by(url);
        }
        return innerHTML;
    };
})(wysihtml5);
/**
 * Force rerendering of a given element
 * Needed to fix display misbehaviors of IE
 *
 * @param {Element} element The element object which needs to be rerendered
 * @example
 *    wysihtml5.quirks.redraw(document.body);
 */
(function (wysihtml5) {
    var CLASS_NAME = "wysihtml5-quirks-redraw";

    wysihtml5.quirks.redraw = function (element) {
        wysihtml5.dom.addClass(element, CLASS_NAME);
        wysihtml5.dom.removeClass(element, CLASS_NAME);

        // Following hack is needed for firefox to make sure that image resize handles are properly removed
        try {
            var doc = element.ownerDocument;
            doc.execCommand("italic", false, null);
            doc.execCommand("italic", false, null);
        } catch (e) {
        }
    };
})(wysihtml5);
/**
 * Selection API
 *
 * @example
 *    var selection = new wysihtml5.Selection(editor);
 */
(function (wysihtml5) {
    var dom = wysihtml5.dom;

    function _getCumulativeOffsetTop(element) {
        var top = 0;
        if (element.parentNode) {
            do {
                top += element.offsetTop || 0;
                element = element.offsetParent;
            } while (element);
        }
        return top;
    }

    wysihtml5.Selection = Base.extend(
        /** @scope wysihtml5.Selection.prototype */ {
            constructor : function (editor) {
                // Make sure that our external range library is initialized
                window.rangy.init();

                this.editor = editor;
                this.composer = editor.composer;
                this.doc = this.composer.doc;
            },

            /**
             * Get the current selection as a bookmark to be able to later restore it
             *
             * @return {Object} An object that represents the current selection
             */
            getBookmark : function () {
                var range = this.getRange();
                return range && range.cloneRange();
            },

            /**
             * Restore a selection retrieved via wysihtml5.Selection.prototype.getBookmark
             *
             * @param {Object} bookmark An object that represents the current selection
             */
            setBookmark : function (bookmark) {
                if (!bookmark) {
                    return;
                }

                this.setSelection(bookmark);
            },

            /**
             * Set the caret in front of the given node
             *
             * @param {Object} node The element or text node where to position the caret in front of
             * @example
             *    selection.setBefore(myElement);
             */
            setBefore : function (node) {
                var range = rangy.createRange(this.doc);
                range.setStartBefore(node);
                range.setEndBefore(node);
                return this.setSelection(range);
            },

            /**
             * Set the caret after the given node
             *
             * @param {Object} node The element or text node where to position the caret in front of
             * @example
             *    selection.setBefore(myElement);
             */
            setAfter : function (node) {
                var range = rangy.createRange(this.doc);
                range.setStartAfter(node);
                range.setEndAfter(node);
                return this.setSelection(range);
            },

            /**
             * Ability to select/mark nodes
             *
             * @param {Element} node The node/element to select
             * @example
             *    selection.selectNode(document.getElementById("my-image"));
             */
            selectNode : function (node, avoidInvisibleSpace) {
                var range = rangy.createRange(this.doc),
                    isElement = node.nodeType === wysihtml5.ELEMENT_NODE,
                    canHaveHTML = "canHaveHTML" in node ? node.canHaveHTML : (node.nodeName !== "IMG"),
                    content = isElement ? node.innerHTML : node.data,
                    isEmpty = (content === "" || content === wysihtml5.INVISIBLE_SPACE),
                    displayStyle = dom.getStyle("display").from(node),
                    isBlockElement = (displayStyle === "block" || displayStyle === "list-item");

                if (isEmpty && isElement && canHaveHTML && !avoidInvisibleSpace) {
                    // Make sure that caret is visible in node by inserting a zero width no breaking space
                    try {
                        node.innerHTML = wysihtml5.INVISIBLE_SPACE;
                    } catch (e) {
                    }
                }

                if (canHaveHTML) {
                    range.selectNodeContents(node);
                } else {
                    range.selectNode(node);
                }

                if (canHaveHTML && isEmpty && isElement) {
                    range.collapse(isBlockElement);
                } else if (canHaveHTML && isEmpty) {
                    range.setStartAfter(node);
                    range.setEndAfter(node);
                }

                this.setSelection(range);
            },

            /**
             * Get the node which contains the selection
             *
             * @param {Boolean} [controlRange] (only IE) Whether it should return the selected ControlRange element when the selection type is a "ControlRange"
             * @return {Object} The node that contains the caret
             * @example
             *    var nodeThatContainsCaret = selection.getSelectedNode();
             */
            getSelectedNode : function (controlRange, excludeEditorContainer) {
                var selection,
                    range,
                    selectedNode = null;

                if (controlRange && this.doc.selection && this.doc.selection.type === "Control") {
                    range = this.doc.selection.createRange();
                    if (range && range.length) {
                        selectedNode = range.item(0);
                    }
                }

                selection = this.getSelection(this.doc);
                if (selection.focusNode === selection.anchorNode) {
                    selectedNode = selection.focusNode;
                } else {
                    range = this.getRange(this.doc);
                    selectedNode = range ? range.commonAncestorContainer : this.editor.composer.sandbox.getContainer();
                }
                if (excludeEditorContainer && wysihtml5.util.isEditorNode(selectedNode)) {
                    selectedNode = null;
                }
                return selectedNode;
            },

            executeAndRestore : function (method, restoreScrollPosition) {
                var body = this.doc.body,
                    oldScrollTop = restoreScrollPosition && body.scrollTop,
                    oldScrollLeft = restoreScrollPosition && body.scrollLeft,
                    className = "_wysihtml5-temp-placeholder",
                    placeholderHtml = '<span class="' + className + '">' + wysihtml5.INVISIBLE_SPACE + '</span>',
                    range = this.getRange(this.doc),
                    caretPlaceholder,
                    newCaretPlaceholder,
                    nextSibling,
                    node,
                    newRange;

                // Nothing selected, execute and say goodbye
                if (!range) {
                    method(body, body);
                    return;
                }

                if (wysihtml5.browser.hasInsertNodeIssue()) {
                    this.doc.execCommand("insertHTML", false, placeholderHtml);
                } else {
                    node = range.createContextualFragment(placeholderHtml);
                    range.insertNode(node);
                }

                // Make sure that a potential error doesn't cause our placeholder element to be left as a placeholder
                try {
                    method(range.startContainer, range.endContainer);
                } catch (e) {
                    setTimeout(function () {
                        throw e;
                    }, 0);
                }

                caretPlaceholder = this.doc.querySelector("." + className);
                if (caretPlaceholder) {
                    newRange = rangy.createRange(this.doc);
                    nextSibling = caretPlaceholder.nextSibling;
                    // Opera is so fucked up when you wanna set focus before a <br>
                    if (wysihtml5.browser.hasInsertNodeIssue() && nextSibling && nextSibling.nodeName === "BR") {
                        newCaretPlaceholder = this.doc.createTextNode(wysihtml5.INVISIBLE_SPACE);
                        dom.insert(newCaretPlaceholder).after(caretPlaceholder);
                        newRange.setStartBefore(newCaretPlaceholder);
                        newRange.setEndBefore(newCaretPlaceholder);
                    } else {
                        newRange.selectNode(caretPlaceholder);
                        newRange.deleteContents();
                    }
                    this.setSelection(newRange);
                } else {
                    // fallback for when all hell breaks loose
                    body.focus();
                }

                if (restoreScrollPosition) {
                    body.scrollTop = oldScrollTop;
                    body.scrollLeft = oldScrollLeft;
                }

                // Remove it again, just to make sure that the placeholder is definitely out of the dom tree
                try {
                    caretPlaceholder.parentNode.removeChild(caretPlaceholder);
                } catch (e2) {
                }
            },

            /**
             * Different approach of preserving the selection (doesn't modify the dom)
             * Takes all text nodes in the selection and saves the selection position in the first and last one
             */
            executeAndRestoreSimple : function (method) {
                var range = this.getRange(),
                    body = this.doc.body,
                    newRange,
                    firstNode,
                    lastNode,
                    textNodes,
                    rangeBackup;

                // Nothing selected, execute and say goodbye
                if (!range) {
                    method(body, body);
                    return;
                }

                textNodes = range.getNodes([3]);
                firstNode = textNodes[0] || range.startContainer;
                lastNode = textNodes[textNodes.length - 1] || range.endContainer;

                rangeBackup = {
                    collapsed : range.collapsed,
                    startContainer : firstNode,
                    startOffset : firstNode === range.startContainer ? range.startOffset : 0,
                    endContainer : lastNode,
                    endOffset : lastNode === range.endContainer ? range.endOffset : lastNode.length
                };

                try {
                    method(range.startContainer, range.endContainer);
                } catch (e) {
                    setTimeout(function () {
                        throw e;
                    }, 0);
                }

                newRange = rangy.createRange(this.doc);
                try {
                    newRange.setStart(rangeBackup.startContainer, rangeBackup.startOffset);
                } catch (e1) {
                }
                try {
                    newRange.setEnd(rangeBackup.endContainer, rangeBackup.endOffset);
                } catch (e2) {
                }
                try {
                    this.setSelection(newRange);
                } catch (e3) {
                }
            },

            set : function (node, offset) {
                var newRange = rangy.createRange(this.doc);
                newRange.setStart(node, offset || 0);
                this.setSelection(newRange);
            },

            /**
             * Insert html at the caret position and move the cursor after the inserted html
             *
             * @param {String} html HTML string to insert
             * @example
             *    selection.insertHTML("<p>foobar</p>");
             */
            insertHTML : function (html) {
                var range = rangy.createRange(this.doc),
                    node = range.createContextualFragment(html),
                    lastChild = node.lastChild;
                this.insertNode(node);
                if (lastChild) {
                    this.setAfter(lastChild);
                }
            },

            /**
             * Insert a node at the caret position and move the cursor behind it
             *
             * @param {Object} node HTML string to insert
             * @example
             *    selection.insertNode(document.createTextNode("foobar"));
             */
            insertNode : function (node) {
                var range = this.getRange();
                if (range) {
                    range.insertNode(node);
                }
            },

            /**
             * Wraps current selection with the given node
             *
             * @param {Object} node The node to surround the selected elements with
             */
            surround : function (node) {
                var range = this.getRange();
                if (!range) {
                    return;
                }

                try {
                    // This only works when the range boundaries are not overlapping other elements
                    range.surroundContents(node);
                    this.selectNode(node);
                } catch (e) {
                    // fallback
                    node.appendChild(range.extractContents());
                    range.insertNode(node);
                }
            },

            /**
             * Scroll the current caret position into the view
             * FIXME: This is a bit hacky, there might be a smarter way of doing this
             *
             * @example
             *    selection.scrollIntoView();
             */
            scrollIntoView : function () {
                var selectedNodes = this.composer.selection.getNodes(3);
                if (selectedNodes && selectedNodes.length > 0) {
                    var firstNode = selectedNodes[0];
                    while (firstNode.nodeType === 3) {
                        firstNode = firstNode.parentElement;
                    }
                    /* Using scrollIntoViewIfNeeded for Chrome and
                     * scrollIntoView for other browsers */
                    if (typeof firstNode.scrollIntoViewIfNeeded === "function") {
                        firstNode.scrollIntoViewIfNeeded();
                    } else if (typeof firstNode.scrollIntoView === "function") {
                        firstNode.scrollIntoView();
                    }
                }
            },

            /**
             * Select line where the caret is in
             */
            selectLine : function () {
                if (wysihtml5.browser.supportsSelectionModify()) {
                    this._selectLine_W3C();
                } else if (this.doc.selection) {
                    this._selectLine_MSIE();
                }
            },

            /**
             * See https://developer.mozilla.org/en/DOM/Selection/modify
             */
            _selectLine_W3C : function () {
                var win = this.doc.defaultView,
                    selection = win.getSelection();
                selection.modify("extend", "left", "lineboundary");
                selection.modify("extend", "right", "lineboundary");
            },

            _selectLine_MSIE : function () {
                var range = this.doc.selection.createRange(),
                    rangeTop = range.boundingTop,
                    rangeHeight = range.boundingHeight,
                    scrollWidth = this.doc.body.scrollWidth,
                    rangeBottom,
                    rangeEnd,
                    measureNode,
                    i,
                    j;

                if (!range.moveToPoint) {
                    return;
                }

                if (rangeTop === 0) {
                    // Don't know why, but when the selection ends at the end of a line
                    // range.boundingTop is 0
                    measureNode = this.doc.createElement("span");
                    this.insertNode(measureNode);
                    rangeTop = measureNode.offsetTop;
                    measureNode.parentNode.removeChild(measureNode);
                }

                rangeTop += 1;

                for (i = -10;
                     i < scrollWidth;
                     i += 2) {
                    try {
                        range.moveToPoint(i, rangeTop);
                        break;
                    } catch (e1) {
                    }
                }

                // Investigate the following in order to handle multi line selections
                rangeBottom = rangeTop + (rangeHeight ? (rangeHeight - 1) : 0);
                //rangeBottom = rangeTop;
                rangeEnd = this.doc.selection.createRange();
                for (j = scrollWidth;
                     j >= 0;
                     j--) {
                    try {
                        rangeEnd.moveToPoint(j, rangeBottom);
                        break;
                    } catch (e2) {
                    }
                }

                range.setEndPoint("EndToEnd", rangeEnd);
                range.select();
            },

            getText : function () {
                var selection = this.getSelection();
                return selection ? selection.toString() : "";
            },

            getNodes : function (nodeType, filter) {
                var range = this.getRange();
                if (range) {
                    return range.getNodes([nodeType], filter);
                } else {
                    return [];
                }
            },

            getRange : function () {
                var selection = this.getSelection();
                /* Check if the focusNode is editor div element or its child
                *  For IE, on selecting text with Ctrl+A the focus node is editor node */
                return selection && selection.rangeCount && (this.composer.container === selection.focusNode || $(this.composer.container).has(selection.focusNode).length > 0) && selection.getRangeAt(0);
            },

            getSelection : function () {
                return rangy.getSelection(this.doc.defaultView || this.doc.parentWindow);
            },
            getCurrentRange : function () {
                var selection = rangy.getSelectionWithoutRefersh(this.doc.defaultView || this.doc.parentWindow);
                return selection && selection.rangeCount && selection.getRangeAt(0);
            },

            setSelection : function (range) {
                var win = this.doc.defaultView || this.doc.parentWindow,
                    selection = rangy.getSelection(win);
                return selection.setSingleRange(range);
            }
        });
})(wysihtml5);
/**
 * Inspired by the rangy CSS Applier module written by Tim Down and licensed under the MIT license.
 * http://code.google.com/p/rangy/
 *
 * changed in order to be able ...
 *    - to use custom tags
 *    - to detect and replace similar css classes via reg exp
 */
(function (wysihtml5, rangy) {
    var defaultTagName = "span";

    var REG_EXP_WHITE_SPACE = /\s+/g;

    function hasClass(el, cssClass, regExp) {
        if (!el.className) {
            return false;
        }

        var matchingClassNames = el.className.match(regExp) || [];
        return matchingClassNames[matchingClassNames.length - 1] === cssClass;
    }

    function hasAttribute(el, attributes) {
        if (el.nodeType == wysihtml5.TEXT_NODE || el.nodeType == 9) {
            return false;
        }
        var st = el.getAttribute("style");
        if (!st) {
            return false;
        }
        for (var attribute in attributes) {
            if (el.style.getPropertyValue(attribute)) {
                var currentAttributeValue = el.style.getPropertyValue(attribute).replace(/px/, "");
                currentAttributeValue = currentAttributeValue.replace(/pt/, "");
                currentAttributeValue = currentAttributeValue.replace(/["']/g, "");
                var newAttributeValue = attributes[attribute] ? attributes[attribute].replace(/px/, "") : null;
                newAttributeValue = newAttributeValue ? newAttributeValue.replace(/pt/, "") : null;
                if (newAttributeValue != null && currentAttributeValue == newAttributeValue) {
                    return true;
                } else if (!attributes[attribute]) {
                    return true;
                }
            }
        }
        return false;
    }

    function addClass(el, cssClass, regExp) {
        if (el.className) {
            removeClass(el, regExp);
            el.className += " " + cssClass;
        } else {
            el.className = cssClass;
        }
    }

    function addAttribute(el, attributes, clearPreStyle) {
        if (clearPreStyle && el) {
            el.removeAttribute("style");
        }
        if (attributes != null) {
            for (attribute in attributes) {
                if (el.style) {
                    el.style.removeProperty(attribute);
                }
                var st = el.getAttribute('style');
                if (st != null) {
                    var index = st.indexOf(attribute);
                    if (attribute == "color") {
                        /* If span had "background-color" in style and we search for "color" then it returns the index of color
                         which is present in "background-color" string. Because of this background-color which was applied earlier was lost.
                         */
                        st = st.replace("background-color", "background-customclr");
                        index = st.indexOf(attribute);
                        st = st.replace("background-customclr", "background-color");
                    }
                    if (index >= 0) {// Contains custom Style attribute try remove if already exists and execpeting custom attribute to contain value true
                        st = st.substr(0, index) + st.substr(index + attribute.length + 6); // adding +6 charcter as we execpeting custom attribute value to true or false end with ;
                    }
                    el.setAttribute('style', attribute + ":" + attributes[attribute] + ";" + st);
                } else {
                    el.setAttribute('style', attribute + ":" + attributes[attribute] + ";");
                }
            }
        }
    }

    function addDataAttribute(el, attributes, clearPreDataAttr) {
        if (el) {
            if (clearPreDataAttr && $(el).data()) {
                var data = $(el).data();
                for (var key in data) {
                    $(el).removeData(key);
                    $(el).removeAttr("data-" + key);
                }
            }
            for (var attribute in attributes) {
                $(el).data(attribute, attributes[attribute]);
                $(el).attr('data-' + attribute, attributes[attribute]);
            }
        }
    }

    function removeClass(el, regExp) {
        if (el.className) {
            el.className = el.className.replace(regExp, "");
        }
    }

    function hasSameClasses(el1, el2) {
        return el1.className.replace(REG_EXP_WHITE_SPACE, " ") == el2.className.replace(REG_EXP_WHITE_SPACE, " ");
    }

    function replaceWithOwnChildren(el) {
        var parent = el.parentNode;
        while (el.firstChild) {
            parent.insertBefore(el.firstChild, el);
        }
        parent.removeChild(el);
    }

    function elementsHaveSameNonClassAttributes(el1, el2) {
        if (el1.attributes.length != el2.attributes.length) {
            return false;
        }
        for (var i = 0, len = el1.attributes.length, attr1, attr2, name;
             i < len;
             ++i) {
            attr1 = el1.attributes[i];
            name = attr1.name;
            if (name != "class") {
                attr2 = el2.attributes.getNamedItem(name);
                if (attr1.specified != attr2.specified) {
                    return false;
                }
                if (attr1.specified && attr1.nodeValue !== attr2.nodeValue) {
                    return false;
                }
            }
        }
        return true;
    }

    function isSplitPoint(node, offset) {
        if (rangy.dom.isCharacterDataNode(node)) {
            if (offset == 0) {
                return !!node.previousSibling;
            } else if (offset == node.length) {
                return !!node.nextSibling;
            } else {
                return true;
            }
        }

        return offset > 0 && offset < node.childNodes.length;
    }

    function splitNodeAt(node, descendantNode, descendantOffset) {
        var newNode;
        if (rangy.dom.isCharacterDataNode(descendantNode)) {
            if (descendantOffset == 0) {
                descendantOffset = rangy.dom.getNodeIndex(descendantNode);
                descendantNode = descendantNode.parentNode;
            } else if (descendantOffset == descendantNode.length) {
                descendantOffset = rangy.dom.getNodeIndex(descendantNode) + 1;
                descendantNode = descendantNode.parentNode;
            } else {
                newNode = rangy.dom.splitDataNode(descendantNode, descendantOffset);
            }
        }
        if (!newNode) {
            newNode = descendantNode.cloneNode(false);
            if (newNode.id) {
                newNode.removeAttribute("id");
            }
            var child;
            while ((child = descendantNode.childNodes[descendantOffset])) {
                newNode.appendChild(child);
            }
            rangy.dom.insertAfter(newNode, descendantNode);
        }
        return (descendantNode == node) ? newNode : splitNodeAt(node, newNode.parentNode, rangy.dom.getNodeIndex(newNode));
    }

    function Merge(firstNode) {
        this.isElementMerge = (firstNode.nodeType == wysihtml5.ELEMENT_NODE);
        this.firstTextNode = this.isElementMerge ? firstNode.lastChild : firstNode;
        this.textNodes = [this.firstTextNode];
    }

    Merge.prototype = {
        doMerge : function () {
            var textBits = [], textNode, parent, text;
            for (var i = 0, len = this.textNodes.length;
                 i < len;
                 ++i) {
                textNode = this.textNodes[i];
                parent = textNode.parentNode;
                textBits[i] = textNode.data;
                if (i) {
                    parent.removeChild(textNode);
                    if (!parent.hasChildNodes()) {
                        parent.parentNode.removeChild(parent);
                    }
                }
            }
            this.firstTextNode.data = text = textBits.join("");
            return text;
        },

        getLength : function () {
            var i = this.textNodes.length, len = 0;
            while (i--) {
                len += this.textNodes[i].length;
            }
            return len;
        },

        toString : function () {
            var textBits = [];
            for (var i = 0, len = this.textNodes.length;
                 i < len;
                 ++i) {
                textBits[i] = "'" + this.textNodes[i].data + "'";
            }
            return "[Merge(" + textBits.join(",") + ")]";
        }
    };

    function HTMLApplier(tagNames, cssClass, similarClassRegExp, normalize, attributes, clearPreStyle, dataAttributes, clearPreDataAttr) {
        this.tagNames = tagNames || [defaultTagName];
        this.cssClass = cssClass || "";
        this.similarClassRegExp = similarClassRegExp;
        this.normalize = normalize;
        this.applyToAnyTagName = false;
        this.attributes = attributes;
        this.clearPreStyle = clearPreStyle;
        this.dataAttributes = dataAttributes;
        this.clearPreDataAttr = clearPreDataAttr;
    }

    HTMLApplier.prototype = {
        getAncestorWithClassAndAttribute : function (node) {
            var cssClassMatch;

            while (node) {
                cssClassMatch = this.cssClass ? hasClass(node, this.cssClass, this.similarClassRegExp) : true;
                var textNode = node;
                if ((textNode.nodeType == wysihtml5.ELEMENT_NODE) && this.attributes) {
                    var attributes = this.attributes;
                    var attributeMatch = true;
                    for (var attribute in attributes) {
                        var attributeValue = textNode.style[attribute];
                        if (attributeValue != attributes[attribute]) {
                            attributeMatch = false;
                            break;
                        }
                    }
                }
                attributeMatch = this.attributes ? attributeMatch : true;

                if (node.nodeType == wysihtml5.ELEMENT_NODE && rangy.dom.arrayContains(this.tagNames, node.tagName.toLowerCase()) && cssClassMatch && attributeMatch) {
                    return node;
                }
                node = node.parentNode;
            }
            return false;
        },
        getAncestor : function (node) {
            if (this.attributes || this.dataAttributes) {
                return this.getAncestorWithAttributes(node);
            } else {
                return this.getAncestorWithClass(node);
            }
        },
        getAncestorWithAttributes : function (node) {
            var attributesMatch;
            if (!this.attributes) {
                return false;
            }
            while (node) {
                attributesMatch = this.attributes ? hasAttribute(node, this.attributes) : true;
                if (node.nodeType == wysihtml5.ELEMENT_NODE && (rangy.dom.arrayContains(this.tagNames, node.tagName.toLowerCase()) || wysihtml5.util.isEditorNode(node)) && attributesMatch) {
                    return node;
                }
                if (node && node.style && this.attributes) {
                    var attrExists = node.style.getPropertyValue((Object.keys(this.attributes))[0]);
                    if (attrExists) {
                        return false;
                    }
                }
                node = node.parentNode;
            }
            return false;
        },
        getAncestorWithClass : function (node) {
            var cssClassMatch;

            while (node) {
                cssClassMatch = this.cssClass ? hasClass(node, this.cssClass, this.similarClassRegExp) : true;
                if (node.nodeType == wysihtml5.ELEMENT_NODE && rangy.dom.arrayContains(this.tagNames, node.tagName.toLowerCase()) && cssClassMatch) {
                    return node;
                }
                node = node.parentNode;
            }
            return false;
        },

        // Normalizes nodes after applying a CSS class to a Range.
        postApply : function (textNodes, range, textNodeNames) {
            var firstNode = textNodes[0], lastNode = textNodes[textNodes.length - 1];

            var merges = [], currentMerge;

            var rangeStartNode = firstNode, rangeEndNode = lastNode;
            var rangeStartOffset = 0, rangeEndOffset = lastNode.length;

            var textNode, precedingTextNode;

            for (var i = 0, len = textNodes.length;
                 i < len;
                 ++i) {
                textNode = textNodes[i];
                precedingTextNode = this.getAdjacentMergeableTextNode(textNode.parentNode, false, textNodeNames);
                if (precedingTextNode) {
                    if (!currentMerge) {
                        currentMerge = new Merge(precedingTextNode);
                        merges.push(currentMerge);
                    }
                    currentMerge.textNodes.push(textNode);
                    if (textNode === firstNode) {
                        rangeStartNode = currentMerge.firstTextNode;
                        rangeStartOffset = rangeStartNode.length;
                    }
                    if (textNode === lastNode) {
                        rangeEndNode = currentMerge.firstTextNode;
                        rangeEndOffset = currentMerge.getLength();
                    }
                } else {
                    currentMerge = null;
                }
            }

            // Test whether the first node after the range needs merging
            var nextTextNode = this.getAdjacentMergeableTextNode(lastNode.parentNode, true);
            if (nextTextNode) {
                if (!currentMerge) {
                    currentMerge = new Merge(lastNode);
                    merges.push(currentMerge);
                }
                currentMerge.textNodes.push(nextTextNode);
            }

            // Do the merges
            if (merges.length) {
                for (i = 0, len = merges.length;
                     i < len;
                     ++i) {
                    merges[i].doMerge();
                }
                // Set the range boundaries
                range.setStart(rangeStartNode, rangeStartOffset);
                range.setEnd(rangeEndNode, rangeEndOffset);
            }
        },

        getAdjacentMergeableTextNode : function (node, forward, textNodeNames) {
            var isTextNode = (node.nodeType == wysihtml5.TEXT_NODE);
            var el = isTextNode ? node.parentNode : node;
            var adjacentNode;
            var propName = forward ? "nextSibling" : "previousSibling";
            if (isTextNode) {
                // Can merge if the node's previous/next sibling is a text node
                adjacentNode = node[propName];
                if (adjacentNode && adjacentNode.nodeType == wysihtml5.TEXT_NODE) {
                    return adjacentNode;
                }
            } else {
                // Compare element with its sibling
                adjacentNode = el[propName];
                if (adjacentNode && this.areElementsMergeable(node, adjacentNode)) {
                    var node = adjacentNode[forward ? "firstChild" : "lastChild"];
                    if (!textNodeNames || textNodeNames.indexOf(node.nodeName) < 0) {
                        return node;
                    }
                }
            }
            return null;
        },

        areElementsMergeable : function (el1, el2) {
            return rangy.dom.arrayContains(this.tagNames, (el1.tagName || "").toLowerCase()) && rangy.dom.arrayContains(this.tagNames, (el2.tagName || "").toLowerCase()) && hasSameClasses(el1, el2) && elementsHaveSameNonClassAttributes(el1, el2);
        },

        createContainer : function (doc) {
            var el = doc.createElement(this.tagNames[0]);
            var attributes = this.attributes;
            var dataAttributes = this.dataAttributes;
            if (this.cssClass) {
                el.className = this.cssClass;
            }

            for (var attribute in attributes) {
                el.style.removeProperty(attribute);
                var st = el.getAttribute('style');
                if (st != null) {
                    el.setAttribute('style', attribute + ":" + attributes[attribute] + ";" + st);
                } else {
                    el.setAttribute('style', attribute + ":" + attributes[attribute] + ";");
                }
            }
            for (attribute in dataAttributes) {
                $(el).data(attribute, dataAttributes[attribute]);
                $(el).attr('data-' + attribute, dataAttributes[attribute]);
            }
            return el;
        },

        applyToTextNode : function (textNode) {
            var parent = textNode.parentNode;
            if (parent.childNodes.length == 1 && rangy.dom.arrayContains(this.tagNames, parent.tagName.toLowerCase())) {
                if (this.cssClass) {
                    addClass(parent, this.cssClass, this.similarClassRegExp);
                }
                addAttribute(parent, this.attributes, this.clearPreStyle);
                addDataAttribute(parent, this.dataAttributes, this.clearPreDataAttr);
            } else {
                var el = this.createContainer(rangy.dom.getDocument(textNode));
                textNode.parentNode.insertBefore(el, textNode);
                el.appendChild(textNode);
            }
        },

        isRemovable : function (el) {
            return rangy.dom.arrayContains(this.tagNames, el.tagName.toLowerCase()) && wysihtml5.lang.string(el.className).trim() == this.cssClass;
        },

        undoToTextNode : function (textNode, range, ancestorWithClass) {
            if (!range.containsNode(ancestorWithClass)) {
                // Split out the portion of the ancestor from which we can remove the CSS class
                var ancestorRange = range.cloneRange();
                ancestorRange.selectNode(ancestorWithClass);

                if (ancestorRange.isPointInRange(range.endContainer, range.endOffset) && isSplitPoint(range.endContainer, range.endOffset)) {
                    splitNodeAt(ancestorWithClass, range.endContainer, range.endOffset);
                    range.setEndAfter(ancestorWithClass);
                }
                if (ancestorRange.isPointInRange(range.startContainer, range.startOffset) && isSplitPoint(range.startContainer, range.startOffset)) {
                    ancestorWithClass = splitNodeAt(ancestorWithClass, range.startContainer, range.startOffset);
                }
            }

            if (this.similarClassRegExp) {
                removeClass(ancestorWithClass, this.similarClassRegExp);
                for (var attribute in this.attributes) {
                    ancestorWithClass.style.removeProperty(attribute);
                }
            }
            if (this.isRemovable(ancestorWithClass)) {
                replaceWithOwnChildren(ancestorWithClass);
            }
        },

        applyToRange : function (range, composer) {
            var applied = this.handleListSelection(range, composer);
            var textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            if (!textNodes.length) {
                try {
                    var node = this.createContainer(range.endContainer.ownerDocument);
                    range.surroundContents(node);
                    this.selectNode(range, node);
                    return;
                } catch (e) {
                }
            }

            range.splitBoundaries();
            textNodes = range.getNodes([wysihtml5.TEXT_NODE]);

            if (textNodes.length) {
                var textNodeNames = [];
                if (composer.config.parserRules && composer.config.parserRules.textNodes) {
                    textNodeNames = composer.config.parserRules.textNodes;
                }
                var textNode;

                for (var i = 0, len = textNodes.length;
                     i < len;
                     ++i) {
                    textNode = textNodes[i];
                    var parentEl = wysihtml5.dom.getParentElement(textNode, {nodeName : textNodeNames});
                    if (parentEl) {
                        textNode = parentEl;
                    }
                    if (!this.getAncestor(textNode)) {
                        this.applyToTextNode(textNode);
                    }
                }
                range.setStart(textNodes[0], 0);
                textNode = textNodes[textNodes.length - 1];
                range.setEnd(textNode, textNode.length);

                if (this.normalize) {
                    this.postApply(textNodes, range, textNodeNames);
                }
            }
        },

        handleListSelection : function (range, composer) {
            nodeList = composer.selection.getNodes(3);
            var handledListSelection = false;
            if (nodeList.length > 0) {
                for (i = 0;
                     i < nodeList.length;
                     i++) {
                    node = nodeList[i];
                    node = node.parentNode;
                    if ((node.nodeName == "LI") && (composer.selection.getText().trim() == node.textContent)) {
                        if (node.childNodes.length == 1 && rangy.dom.arrayContains(this.tagNames, node.tagName.toLowerCase())) {
                            if (this.cssClass) {
                                addClass(node, this.cssClass, this.similarClassRegExp);
                            }
                            addAttribute(node, this.attributes, this.clearPreStyle);
                            addDataAttribute(parent, this.dataAttributes, this.clearPreDataAttr);
                        }
                        return true;
                    } else if (!wysihtml5.util.isEditorNode(node)) {
                        while (!(node.nodeName == "LI") && !wysihtml5.util.isEditorNode(node)) {
                            node = node.parentElement;
                        }
                        if ((node.textContent && composer.selection.getText().trim().indexOf(node.textContent.trim()) > -1) && !wysihtml5.util.isEditorNode(node)) {
                            if (this.cssClass) {
                                addClass(node, this.cssClass, this.similarClassRegExp);
                            }
                            addAttribute(node, this.attributes, this.clearPreStyle);
                            addDataAttribute(parent, this.dataAttributes, this.clearPreDataAttr);
                            handledListSelection = true;
                        }
                    }
                }
            } else {
                var selectedNode = composer.selection.getSelectedNode();
                if (selectedNode && selectedNode != undefined) {
                    while (!(selectedNode.nodeName == "LI") && !wysihtml5.util.isEditorNode(selectedNode) && selectedNode.nodeName != "#text") {
                        selectedNode = selectedNode.parentElement;
                    }
                    //CQ-4225614
                    if (composer.selection.getText().trim().indexOf(selectedNode.textContent) > -1 && !wysihtml5.util.isEditorNode(selectedNode)) {
                        if (this.cssClass) {
                            addClass(selectedNode, this.cssClass, this.similarClassRegExp);
                        }
                        addAttribute(selectedNode, this.attributes, this.clearPreStyle);
                        addDataAttribute(parent, this.dataAttributes, this.clearPreDataAttr);
                        handledListSelection = true;
                    }
                }
            }
            return handledListSelection;
        },

        undoToRange : function (range, composer) {
            var textNodes = range.getNodes([wysihtml5.TEXT_NODE]), textNode, ancestorWithClass;
            if (textNodes.length) {
                range.splitBoundaries();
                textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            } else {
                var doc = range.endContainer.ownerDocument,
                    node = doc.createTextNode(wysihtml5.INVISIBLE_SPACE);
                range.insertNode(node);
                range.selectNode(node);
                textNodes = [node];
            }

            for (var i = 0, len = textNodes.length;
                 i < len;
                 ++i) {
                textNode = textNodes[i];
                ancestorWithClass = this.getAncestor(textNode);
                if (ancestorWithClass) {
                    this.undoToTextNode(textNode, range, ancestorWithClass);
                }
            }

            if (len == 1) {
                this.selectNode(range, textNodes[0]);
            } else {
                range.setStart(textNodes[0], 0);
                textNode = textNodes[textNodes.length - 1];
                range.setEnd(textNode, textNode.length);

                if (this.normalize) {
                    this.postApply(textNodes, range);
                }
            }
        },

        selectNode : function (range, node) {
            var isElement = node.nodeType === wysihtml5.ELEMENT_NODE,
                canHaveHTML = "canHaveHTML" in node ? node.canHaveHTML : true,
                content = isElement ? node.innerHTML : node.data,
                isEmpty = (content === "" || content === wysihtml5.INVISIBLE_SPACE);

            if (isEmpty && isElement && canHaveHTML) {
                // Make sure that caret is visible in node by inserting a zero width no breaking space
                try {
                    node.innerHTML = wysihtml5.INVISIBLE_SPACE;
                } catch (e) {
                }
            }
            range.selectNodeContents(node);
            if (isEmpty && isElement) {
                range.collapse(false);
            } else if (isEmpty) {
                range.setStartAfter(node);
                range.setEndAfter(node);
            }
        },

        getTextSelectedByRange : function (textNode, range) {
            var textRange = range.cloneRange();
            textRange.selectNodeContents(textNode);

            var intersectionRange = textRange.intersection(range);
            var text = intersectionRange ? intersectionRange.toString() : "";
            textRange.detach();

            return text;
        },

        isAppliedToRangeByClassAndAttribute : function (range) {

            var textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            var attributes = this.attributes;
            var attributeValue = new Array();
            if (textNodes.length) {
                var textNode;
                for (var i = 0, len = textNodes.length;
                     i < len;
                     i++) {
                    textNode = textNodes[i];
                    while (!wysihtml5.util.isEditorNode(textNode)) {
                        var textNode = textNode.parentNode;
                        var j = 0;
                        for (var attribute in attributes) {
                            if (!attributeValue[j]) {
                                if (textNode.style.getPropertyValue(attribute) == attributes[attribute]) {
                                    attributeValue[j++] = "true";
                                }
                            }
                        }
                        if (this.dataAttributes) {
                            for (attribute in this.dataAttributes) {
                                if (!attributeValue[j]) {
                                    if ($(textNode).data(attribute) == this.dataAttributes[attribute]) {
                                        attributeValue[j++] = "true";
                                    }
                                }
                            }
                        }
                    }
                }
            }
            var i = 0;
            for (attribute in attributes) {
                if (!attributeValue[i++]) {
                    return false;
                }
            }
            var ancestors = [],
                ancestor,
                textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            if (!textNodes.length) {
                ancestor = this.getAncestorWithAttributes(range.startContainer);
                return ancestor ? [ancestor] : false;
            }

            for (var i = 0, len = textNodes.length, selectedText;
                 i < len;
                 ++i) {
                selectedText = this.getTextSelectedByRange(textNodes[i], range);
                ancestor = this.getAncestorWithAttributes(textNodes[i]);
                if (selectedText != "" && !ancestor) {
                    return false;
                } else {
                    ancestors.push(ancestor);
                }
            }
            return ancestors;
        },

        isAppliedToRange : function (range) {

            var ancestors = [],
                ancestor,
                textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            if (!textNodes.length) {
                ancestor = this.getAncestor(range.startContainer);
                return ancestor ? [ancestor] : false;
            }

            for (var i = 0, len = textNodes.length, selectedText;
                 i < len;
                 ++i) {
                selectedText = this.getTextSelectedByRange(textNodes[i], range);
                ancestor = this.getAncestor(textNodes[i]);
                if (selectedText != "" && !ancestor) {
                    return false;
                } else {
                    ancestors.push(ancestor);
                }
            }
            return ancestors;
        },

        toggleRange : function (range, composer) {
            var isApply = false;
            if (this.attributes || this.dataAttributes) {
                isApply = this.isAppliedToRangeByClassAndAttribute(range);
            } else {
                isApply = this.isAppliedToRange(range);
            }

            if (isApply) {
                this.undoToRange(range, composer);
            } else {
                this.applyToRange(range, composer);
            }
        }
    };

    wysihtml5.selection.HTMLApplier = HTMLApplier;
})(wysihtml5, rangy);
/**
 * Rich Text Query/Formatting Commands
 *
 * @example
 *    var commands = new wysihtml5.Commands(editor);
 */
wysihtml5.Commands = Base.extend(
    /** @scope wysihtml5.Commands.prototype */ {
        constructor : function (editor) {
            this.editor = editor;
            this.composer = editor.composer;
            this.doc = this.composer.doc;
        },

        /**
         * Check whether the browser supports the given command
         *
         * @param {String} command The command string which to check (eg. "bold", "italic", "insertUnorderedList")
         * @example
         *    commands.supports("createLink");
         */
        support : function (command) {
            return wysihtml5.browser.supportsCommand(this.doc, command);
        },

        /**
         * Check whether the browser supports the given command
         *
         * @param {String} command The command string which to execute (eg. "bold", "italic", "insertUnorderedList")
         * @param {String} [value] The command value parameter, needed for some commands ("createLink", "insertImage", ...), optional for commands that don't require one ("bold", "underline", ...)
         * @example
         *    commands.exec("insertImage", "http://a1.twimg.com/profile_images/113868655/schrei_twitter_reasonably_small.jpg");
         */
        exec : function (command, value, allowUndo) {
            var obj = wysihtml5.commands[command],
                args = wysihtml5.lang.array(arguments).get(),
                method = obj && obj.exec,
                focus = obj && obj.focus,
                result = null;

            if (allowUndo == undefined) {
                allowUndo = true;
            }
            if (focus == undefined) {
                focus = true;
            }

            if (allowUndo) {
                this.editor.fire("beforecommand:composer");
            }

            if (method) {
                args.unshift(this.composer);
                // Make sure that composer is focussed (false => don't move caret to the end)
                var range = this.composer.selection.getRange();
                if (focus) {
                    this.editor.focus(false);
                }
                if (focus && this.editor.savedSelection && !range) {// Fixing LC-3911994
                    this.composer.selection.setSelection(this.editor.savedSelection);
                }
                result = method.apply(obj, args);
            } else {
                try {
                    // try/catch for buggy firefox
                    result = this.doc.execCommand(command, false, value);
                } catch (e) {
                }
            }

            this.editor.fire("aftercommand:composer");
            return result;
        },

        /**
         * Check whether the current command is active
         * If the caret is within a bold text, then calling this with command "bold" should return true
         *
         * @param {String} command The command string which to check (eg. "bold", "italic", "insertUnorderedList")
         * @param {String} [commandValue] The command value parameter (eg. for "insertImage" the image src)
         * @return {Boolean} Whether the command is active
         * @example
         *    var isCurrentSelectionBold = commands.state("bold");
         */
        state : function (command, commandValue) {
            var obj = wysihtml5.commands[command],
                args = wysihtml5.lang.array(arguments).get(),
                method = obj && obj.state;
            return this.callStateFunction(method, obj, args, command);
        },

        callbackState : function (command, commandValue, isDefault) {
            var obj = wysihtml5.commands[command],
                args = wysihtml5.lang.array(arguments).get(), method;
            if (obj && obj.callbackState) {
                method = obj && obj.callbackState;
                return this.callStateFunction(method, obj, args, command);
            } else {
                return this.state(command, commandValue, isDefault);
            }
        },

        callStateFunction : function (method, obj, args, command) {
            if (method) {
                args.unshift(this.composer);
                return method.apply(obj, args);
            } else {
                try {
                    // try/catch for buggy firefox
                    return this.doc.queryCommandState(command);
                } catch (e) {
                    return false;
                }
            }
        }
    });
wysihtml5.commands.bold = {
    exec : function (composer, command) {
        return wysihtml5.commands.formatInline.exec(composer, command, "b");
    },

    state : function (composer, command) {
        // element.ownerDocument.queryCommandState("bold") results:
        // firefox: only <b>
        // chrome:  <b>, <strong>, <h1>, <h2>, ...
        // ie:      <b>, <strong>
        // opera:   <b>, <strong>
        return wysihtml5.commands.formatInline.state(composer, command, "b");
    }
};

wysihtml5.commands.superScript = {
    exec : function (composer, command) {
        var doc = composer.doc,
            selectedNode = composer.selection.getSelectedNode(),
            subscript = selectedNode.parentNode.nodeName;
        if (composer.commands.support(command)) {
            composer.doc.execCommand(command, false, null);
        } else {
            if (subscript && subscript == "SUB") {
                var el = composer.selection.executeAndRestore(function () {
                    wysihtml5.dom.renameElement(selectedNode.parentNode, "sup");
                });
            } else {
                wysihtml5.commands.formatInline.exec(composer, command, "sup");
            }
        }
    },

    state : function (composer, command) {
        return wysihtml5.commands.formatInline.state(composer, command, "sup");
    }
};

wysihtml5.commands.subScript = {
    exec : function (composer, command) {
        var doc = composer.doc,
            selectedNode = composer.selection.getSelectedNode(),
            superscript = selectedNode.parentNode.nodeName;
        if (composer.commands.support(command)) {
            composer.doc.execCommand(command, false, null);
        } else {
            if (superscript && superscript == "SUP") {
                var el = composer.selection.executeAndRestore(function () {
                    wysihtml5.dom.renameElement(selectedNode.parentNode, "sub");
                });
            } else {
                wysihtml5.commands.formatInline.exec(composer, command, "sub");
            }
        }
    },

    state : function (composer, command) {
        return wysihtml5.commands.formatInline.state(composer, command, "sub");
    }
};

(function (wysihtml5) {
    var undef,
        NODE_NAME = "A",
        dom = wysihtml5.dom;

    function _removeFormat(composer, anchors) {
        var length = anchors.length,
            i = 0,
            anchor,
            codeElement,
            textContent;
        for (;
            i < length;
            i++) {
            anchor = anchors[i];
            codeElement = dom.getParentElement(anchor, {nodeName : "code"});
            textContent = dom.getTextContent(anchor);

            // if <a> contains url-like text content, rename it to <code> to prevent re-autolinking
            // else replace <a> with its childNodes
            if (textContent.match(dom.autoLink.URL_REG_EXP) && !codeElement) {
                // <code> element is used to prevent later auto-linking of the content
                codeElement = dom.renameElement(anchor, "code");
            } else {
                dom.replaceWithChildNodes(anchor);
            }
        }
    }

    function _format(composer, attributes) {
        var doc = composer.doc,
            tempClass = "_wysihtml5-temp-" + (+new Date()),
            tempClassRegExp = /non-matching-class/g,
            i = 0,
            length,
            anchors,
            anchor,
            hasElementChild,
            isEmpty,
            elementToSetCaretAfter,
            textContent,
            whiteSpace,
            j;
        wysihtml5.commands.formatInline.exec(composer, undef, NODE_NAME, tempClass, tempClassRegExp);

        var newText = null;
        if (attributes && attributes.alt) {
            newText = attributes.alt;
            delete attributes.alt;
        }

        anchors = doc.querySelectorAll(NODE_NAME + "." + tempClass);
        length = anchors.length;
        for (;
            i < length;
            i++) {
            anchor = anchors[i];
            anchor.removeAttribute("class");
            for (j in attributes) {
                anchor.setAttribute(j, attributes[j]);
            }
            if (newText) {
                anchor.text = newText;
            }
        }

        elementToSetCaretAfter = anchor;
        if (length === 1) {
            textContent = dom.getTextContent(anchor);
            hasElementChild = !!anchor.querySelector("*");
            isEmpty = textContent === "" || textContent === wysihtml5.INVISIBLE_SPACE;
            if (!hasElementChild && isEmpty) {
                dom.setTextContent(anchor, attributes.text || anchor.href);
                whiteSpace = doc.createTextNode(" ");
                composer.selection.setAfter(anchor);
                dom.insert(whiteSpace).after(anchor);
                elementToSetCaretAfter = whiteSpace;
            }
        }
        composer.selection.setAfter(elementToSetCaretAfter);
    }

    wysihtml5.commands.createLink = {
        /**
         * TODO: Use HTMLApplier or formatInline here
         *
         * Turns selection into a link
         * If selection is already a link, it removes the link and wraps it with a <code> element
         * The <code> element is needed to avoid auto linking
         *
         * @example
         *    // either ...
         *    wysihtml5.commands.createLink.exec(composer, "createLink", "http://www.google.de");
         *    // ... or ...
         *    wysihtml5.commands.createLink.exec(composer, "createLink", { href: "http://www.google.de", target: "_blank" });
         */
        exec : function (composer, command, value, alt, target) {
            var anchors = this.state(composer, command);
            // if (anchors) {
            // Selection contains links
            //   composer.selection.executeAndRestore(function() {
            //     _removeFormat(composer, anchors);
            //   });
            // }
            if (typeof value === "object") {
                alt = value.alt;
                target = value.target ? "_target" : "";
                value = value.url;
            }
            for (i = 0;
                 (anchors && (i < anchors.length));
                 i++) {
                var anchor = anchors[i];
                anchor.href = value;
                anchor.title = "Link: " + value;
                anchor.alt = alt;
                anchor.target = target;
            }
            if (!anchors) {
                // Create links
                value = typeof(value) === "object" ? value : {href : value, alt : alt, target : target};
                _format(composer, value);
            }
        },

        state : function (composer, command) {
            return wysihtml5.commands.formatInline.state(composer, command, "A");
        }
    };
})(wysihtml5);
/**
 * document.execCommand("fontSize") will create either inline styles (firefox, chrome) or use font tags
 * which we don't want
 * Instead we set a css class
 */
(function (wysihtml5) {
    var undef,
        REG_EXP = /font-size/g;

    wysihtml5.commands.fontSize = {
        exec : function (composer, command, size) {
            size = size + "pt";
            var attributes = {"font-size" : size};
            wysihtml5.commands.formatInline.exec(composer, command, "span", "font-size", REG_EXP, attributes);
            var domElem = wysihtml5.commands.formatBlock.state(composer, 'lineHeight', attributes);
            var leading;
            if (domElem && domElem.getAttribute) {
                leading = (domElem).getAttribute("leading");
            }
            wysihtml5.util.changeLineHeight(leading, false, 'P', composer);
        },

        state : function (composer, command, size) {
            if (size) {
                size = size + "pt";
            }
            var attributes = {"font-size" : size};
            return wysihtml5.commands.formatInline.state(composer, command, "span", "font-size", REG_EXP, attributes);
        },
        callbackState : function (composer, command, size) {
            var domElem = this.state(composer, command);
            var value = [];
            // domElement i.e Selected text nodes exist
            if (domElem && domElem.length) {
                for (var i = 0; i < domElem.length; i++) {
                    // getting different font sizes applied to selected texts
                    var fontSize =  wysihtml5.helperFn.getPropertyValue(domElem[i], "font-size");
                    // font size is not already retrieved from selected texts, add font size
                    if (!value.includes(fontSize)) {
                        value.push(fontSize);
                    }
                }
            }
            return value;
        },
        value : function () {
            return undef;
        }
    };
})(wysihtml5);
/**
 * document.execCommand("    ") will create either inline styles (firefox, chrome) or use font tags
 * which we don't want
 * Instead we set a css class
 */
(function (wysihtml5) {
    var REG_EXP = /wysiwyg-color-[0-9a-z]+/g;

    wysihtml5.commands.foreColor = {
        exec : function (composer, command, color) {
            var attributes = {"color" : color};

            return wysihtml5.commands.formatInline.exec(composer, command, "span", "wysiwyg-color-" + color, REG_EXP, attributes);
        },

        state : function (composer, command, color) {
            var attributes = {"color" : color};
            return wysihtml5.commands.formatInline.state(composer, command, "span", "wysiwyg-color-" + color, REG_EXP, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        // Following elements are grouped
        // when the caret is within a H1 and the H4 is invoked, the H1 should turn into H4
        // instead of creating a H4 within a H1 which would result in semantically invalid html
        BLOCK_ELEMENTS_GROUP = ["H1", "H2", "H3", "H4", "H5", "H6", "P", "BLOCKQUOTE", "DIV"];

    /**
     * Remove similiar classes (based on classRegExp)
     * and add the desired class name
     */
    function _addClass(element, className, classRegExp) {
        if (element.className) {
            _removeClass(element, classRegExp);
            element.className += " " + className;
        } else {
            element.className = className;
        }
    }

    function _addAttribute(element) {
        var attributes = this.attributes;
        if (element) {
            if (this.clearPreStyle) {
                element.removeAttribute("style");
            }
            for (var attribute in attributes) {
                if (element.style) {
                    element.style.removeProperty(attribute);
                }
                var st = element.getAttribute('style');
                if (st != null) {
                    element.setAttribute('style', attribute + ":" + attributes[attribute] + ";" + st);
                } else {
                    element.setAttribute('style', attribute + ":" + attributes[attribute] + ";");
                }
            }
        }
    }

    function _addDataAttribute(element) {
        if (element) {
            var dataAttributes = this.dataAttributes;
            if (this.clearPreDataAttr && $(element).data()) {
                var data = $(element).data();
                for (var key in data) {
                    $(element).removeData(key);
                    $(el).removeAttr("data-" + key);
                }
            }
            for (var attribute in dataAttributes) {
                $(element).data(attribute, attributes[attribute]);
                $(element).attr('data-' + attribute, attributes[attribute]);
            }
        }
    }

    function _removeClass(element, classRegExp) {
        element.className = element.className.replace(classRegExp, "");
    }

    /**
     * Check whether given node is a text node and whether it's empty
     */
    function _isBlankTextNode(node) {
        return node.nodeType === wysihtml5.TEXT_NODE && !wysihtml5.lang.string(node.data).trim();
    }

    /**
     * Returns previous sibling node that is not a blank text node
     */
    function _getPreviousSiblingThatIsNotBlank(node) {
        var previousSibling = node.previousSibling;
        while (previousSibling && _isBlankTextNode(previousSibling)) {
            previousSibling = previousSibling.previousSibling;
        }
        return previousSibling;
    }

    /**
     * Returns next sibling node that is not a blank text node
     */
    function _getNextSiblingThatIsNotBlank(node) {
        var nextSibling = node.nextSibling;
        while (nextSibling && _isBlankTextNode(nextSibling)) {
            nextSibling = nextSibling.nextSibling;
        }
        return nextSibling;
    }

    /**
     * Adds line breaks before and after the given node if the previous and next siblings
     * aren't already causing a visual line break (block element or <br>)
     */
    function _addLineBreakBeforeAndAfter(node) {
        var doc = node.ownerDocument,
            nextSibling = _getNextSiblingThatIsNotBlank(node),
            previousSibling = _getPreviousSiblingThatIsNotBlank(node);

        if (nextSibling && !_isLineBreakOrBlockElement(nextSibling)) {
            node.parentNode.insertBefore(doc.createElement("br"), nextSibling);
        }
        if (previousSibling && !_isLineBreakOrBlockElement(previousSibling)) {
            node.parentNode.insertBefore(doc.createElement("br"), node);
        }
    }

    /**
     * Removes line breaks before and after the given node
     */
    function _removeLineBreakBeforeAndAfter(node) {
        var nextSibling = _getNextSiblingThatIsNotBlank(node),
            previousSibling = _getPreviousSiblingThatIsNotBlank(node);

        if (nextSibling && _isLineBreak(nextSibling)) {
            nextSibling.parentNode.removeChild(nextSibling);
        }
        if (previousSibling && _isLineBreak(previousSibling)) {
            previousSibling.parentNode.removeChild(previousSibling);
        }
    }

    function _removeLastChildIfLineBreak(node) {
        var lastChild = node.lastChild;
        if (lastChild && _isLineBreak(lastChild)) {
            lastChild.parentNode.removeChild(lastChild);
        }
    }

    function _isLineBreak(node) {
        return node.nodeName === "BR";
    }

    /**
     * Checks whether the elment causes a visual line break
     * (<br> or block elements)
     */
    function _isLineBreakOrBlockElement(element) {
        if (_isLineBreak(element)) {
            return true;
        }

        if (dom.getStyle("display").from(element) === "block") {
            return true;
        }

        return false;
    }

    /**
     * Execute native query command
     * and if necessary modify the inserted node's className
     */
    function _execCommand(doc, command, nodeName, className) {
        if (className) {
            var eventListener = dom.observe(doc, "DOMNodeInserted", function (event) {
                var target = event.target,
                    displayStyle;
                if (target.nodeType !== wysihtml5.ELEMENT_NODE) {
                    return;
                }
                displayStyle = dom.getStyle("display").from(target);
                if (displayStyle.substr(0, 6) !== "inline") {
                    // Make sure that only block elements receive the given class
                    target.className += " " + className;
                }
            });
        }
        doc.execCommand(command, false, nodeName);
        if (eventListener) {
            eventListener.stop();
        }
    }

    function _selectLineAndWrap(composer, element) {
        composer.selection.selectLine();
        composer.selection.surround(element);
        _removeLineBreakBeforeAndAfter(element);
        _removeLastChildIfLineBreak(element);
        composer.selection.selectNode(element, wysihtml5.browser.displaysCaretInEmptyContentEditableCorrectly());
    }

    function _hasClasses(element) {
        return !!wysihtml5.lang.string(element.className).trim();
    }

    wysihtml5.commands.formatBlock = {
        exec : function (composer, command, nodeName, className, classRegExp) {
            var doc = composer.doc,
                blockElement = this.state(composer, command, nodeName, className, classRegExp),
                useLineBreaks = composer.config.useLineBreaks,
                defaultNodeName = useLineBreaks ? "DIV" : "P",
                selectedNode;

            nodeName = typeof(nodeName) === "string" ? nodeName.toUpperCase() : nodeName;

            if (blockElement) {
                composer.selection.executeAndRestoreSimple(function () {
                    if (classRegExp) {
                        _removeClass(blockElement, classRegExp);
                    }
                    var hasClasses = _hasClasses(blockElement);
                    if (!hasClasses && (useLineBreaks || nodeName === "P")) {
                        // Insert a line break afterwards and beforewards when there are siblings
                        // that are not of type line break or block element
                        _addLineBreakBeforeAndAfter(blockElement);
                        dom.replaceWithChildNodes(blockElement);
                    } else {
                        // Make sure that styling is kept by renaming the element to a <div> or <p> and copying over the class name
                        dom.renameElement(blockElement, nodeName === "P" ? "DIV" : defaultNodeName);
                    }
                });
                return;
            }

            // Find similiar block element and rename it (<h2 class="foo"></h2>  =>  <h1 class="foo"></h1>)
            if (nodeName === null || wysihtml5.lang.array(BLOCK_ELEMENTS_GROUP).contains(nodeName)) {
                selectedNode = composer.selection.getSelectedNode(undefined, true);
                blockElement = dom.getParentElement(selectedNode, {
                    nodeName : BLOCK_ELEMENTS_GROUP
                });

                if (blockElement) {
                    composer.selection.executeAndRestore(function () {
                        // Rename current block element to new block element and add class
                        if (nodeName) {
                            blockElement = dom.renameElement(blockElement, nodeName);
                        }
                        if (className) {
                            _addClass(blockElement, className, classRegExp);
                            _addAttribute(blockElement);
                            _addDataAttribute(blockElement);
                        }
                    });
                    return;
                }
            }

            if (composer.commands.support(command)) {
                _execCommand(doc, command, nodeName || defaultNodeName, className);
                return;
            }

            blockElement = doc.createElement(nodeName || defaultNodeName);
            if (className) {
                blockElement.className = className;
            }
            _selectLineAndWrap(composer, blockElement);
        },

        state : function (composer, command, nodeName, className, classRegExp, attributes) {
            nodeName = typeof(nodeName) === "string" ? nodeName.toUpperCase() : nodeName;
            var nodeList = composer.selection.getNodes(3);
            if (nodeList.length > 0) {
                for (i = 0;
                     i < nodeList.length;
                     i++) {
                    var node = nodeList[i];
                    if (node.textContent.trim() != "") {
                        var element = dom.getParentElement(node, {
                            nodeName : nodeName,
                            className : className,
                            classRegExp : classRegExp,
                            attributes : attributes
                        });
                        if (element == null) {
                            return null;
                        }
                    }
                }
                return element;
            } else {
                var selectedNode = composer.selection.getSelectedNode();
                return dom.getParentElement(selectedNode, {
                    nodeName : nodeName,
                    className : className,
                    classRegExp : classRegExp,
                    attributes : attributes
                });
            }
        }
    };

    /**
     * Removes empty tags before and after the given node
     */
    function _removeEmptyTagsBeforeAndAfter(node) {
        var nextSibling = _getNextSiblingThatIsNotBlank(node),
            previousSibling = _getPreviousSiblingThatIsNotBlank(node);

        if (nextSibling && !nextSibling.textContent) {
            nextSibling.parentNode.removeChild(nextSibling);
        }
        if (previousSibling && !previousSibling.textContent) {
            previousSibling.parentNode.removeChild(previousSibling);
        }
    }

    wysihtml5.commands.surroundContent = {
        exec : function (composer, command, element, emptyText) {
            var selectedNode = composer.selection.getSelectedNode(),
                isEmpty = !composer.selection.getText(),
                textNodeNames = [];
            if (composer.config.parserRules && composer.config.parserRules.textNodes) {
                textNodeNames = composer.config.parserRules.textNodes;
            }
            var textNode = wysihtml5.dom.getParentElement(selectedNode, {nodeName : textNodeNames});
            if (textNode) {
                textNode.parentElement.insertBefore(element, textNode);
                element.appendChild(textNode);
            } else if (!wysihtml5.util.isEditorNode(selectedNode) && selectedNode.textContent == composer.selection.getText()) {
                selectedNode.parentElement.insertBefore(element, selectedNode);
                element.appendChild(selectedNode);
            } else {
                composer.selection.surround(element);
            }
            _removeEmptyTagsBeforeAndAfter(element);
            if (isEmpty) {
                /* If the added element is empty add a placeholder text*/
                var firstChild = element;
                while (firstChild.firstChild && firstChild.firstChild.nodeType == 1 && firstChild.firstChild.nodeName != "BR") {
                    firstChild = firstChild.firstChild;
                }
                firstChild.textContent = emptyText;
            }
            var child;
            if (!element.nextSibling || !element.nextSibling.textContent) {
                /* If the element has no next sibling add an element
                 * with same style as last child of the element and &nbsp
                 * to enable cursor to enter the element */
                if (element.nextSibling && element.nextSibling.nodeType == 1) {
                    child = element.nextSibling;
                    while (child.firstChild && child.firstChild.nodeType === 1) {
                        child = child.firstChild;
                    }
                } else {
                    var lastChild = element.lastChild;
                    var supportedTags = ["P", "H1", "H2", "H3", "H4", "H5", "H6", "SPAN", "B", "U", "I", "SUP", "SUB", "A"];
                    while (lastChild.nodeType === 1 && supportedTags.indexOf(lastChild.nodeName) < 0) {
                        lastChild = lastChild.lastChild;
                    }
                    /* If last child type is not text, clone all the child nodes
                     * else append a span tag*/
                    if (lastChild.nodeType === 1) {
                        var cloneNode = lastChild.cloneNode();
                        if (element.nextSibling) {
                            element.parentElement.insertBefore(cloneNode, element.nextSibling);
                        } else {
                            element.parentElement.appendChild(cloneNode);
                        }
                        while (lastChild.lastChild && lastChild.lastChild.nodeType === 1) {
                            lastChild = lastChild.lastChild;
                            /* Skip all condition/repeat and list tags*/
                            if (supportedTags.indexOf(lastChild.nodeName) < 0) {
                                continue;
                            }
                            child = lastChild.cloneNode();
                            cloneNode.appendChild(child);
                            cloneNode = child;
                        }
                    } else {
                        child = document.createElement("span");
                        element.parentElement.appendChild(child);
                    }
                }
                if (child) {
                    child.innerHTML = "&nbsp";
                }
            }
            var range = rangy.createRange(composer.doc);
            range.selectNodeContents(element);
            composer.selection.setSelection(range);
        }
    };
})(wysihtml5);
/**
 * formatInline scenarios for tag "B" (| = caret, |foo| = selected text)
 *
 *   #1 caret in unformatted text:
 *      abcdefg|
 *   output:
 *      abcdefg<b>|</b>
 *
 *   #2 unformatted text selected:
 *      abc|deg|h
 *   output:
 *      abc<b>|deg|</b>h
 *
 *   #3 unformatted text selected across boundaries:
 *      ab|c <span>defg|h</span>
 *   output:
 *      ab<b>|c </b><span><b>defg</b>|h</span>
 *
 *   #4 formatted text entirely selected
 *      <b>|abc|</b>
 *   output:
 *      |abc|
 *
 *   #5 formatted text partially selected
 *      <b>ab|c|</b>
 *   output:
 *      <b>ab</b>|c|
 *
 *   #6 formatted text selected across boundaries
 *      <span>ab|c</span> <b>de|fgh</b>
 *   output:
 *      <span>ab|c</span> de|<b>fgh</b>
 */
(function (wysihtml5) {
    var // Treat <b> as <strong> and vice versa
        ALIAS_MAPPING = {
            "strong" : "b",
            "em" : "i",
            "b" : "strong",
            "i" : "em"
        },
        htmlApplier = {};

    function _getTagNames(tagName) {
        var alias = ALIAS_MAPPING[tagName];
        if (tagName.toLowerCase() == 'span') {
            return alias ? [tagName.toLowerCase(), alias.toLowerCase(), "li", "p"] : [tagName.toLowerCase(), "li", "p"];
        } else {
            return alias ? [tagName.toLowerCase(), alias.toLowerCase()] : [tagName.toLowerCase()];
        }
    }

    function _getApplier(tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute) {
        var identifier = "";
        if (attributes) {
            for (attribute in attributes) {
                identifier = tagName + ":" + className + ":" + attributes[attribute];
                break;
            }
        }
        if (dataAttribute) {
            for (attribute in dataAttribute) {
                identifier += tagName + ":" + className + ":" + dataAttribute[attribute];
            }
        } else if (identifier == "") {
            identifier = tagName + ":" + className;
        }
        if (!htmlApplier[identifier]) {
            htmlApplier[identifier] = new wysihtml5.selection.HTMLApplier(_getTagNames(tagName), className, classRegExp, true, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute);
        }
        return htmlApplier[identifier];
    }

    wysihtml5.commands.formatInline = {
        exec : function (composer, command, tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute) {
            var range = composer.selection.getRange();
            if (!range) {
                return false;
            }
            _getApplier(tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute).toggleRange(range, composer);
            composer.selection.setSelection(range);
        },
        state : function (composer, command, tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute) {
            var doc = composer.doc,
                aliasTagName = ALIAS_MAPPING[tagName] || tagName,
                range;

            // Check whether the document contains a node with the desired tagName
            if (!wysihtml5.dom.hasElementWithTagName(doc, tagName) && !wysihtml5.dom.hasElementWithTagName(doc, aliasTagName)) {
                return false;
            }

            // Check whether the document contains a node with the desired className
            //if (className && !wysihtml5.dom.hasElementWithClassName(doc, className)) {
            //   return false;
            //}

            range = composer.selection.getRange();
            if (!range) {
                return false;
            }
            return _getApplier(tagName, className, classRegExp, attributes, clearPreStyle, dataAttribute, clearPreDataAttribute).isAppliedToRange(range);
        }
    };
})(wysihtml5);
wysihtml5.commands.insertHTML = {
    exec : function (composer, command, html) {
        if (composer.commands.support(command)) {
            composer.doc.execCommand(command, false, html);
        } else {
            composer.selection.insertHTML(html);
        }
    },

    state : function () {
        return false;
    }
};
(wysihtml5);
wysihtml5.commands.insertText = {
    exec : function (composer, command, text) {
        if (composer.commands.support(command)) {
            composer.doc.execCommand(command, false, text);
        } else {
            if (composer.selection && composer.selection.getText() != "") {
                composer.doc.execCommand("delete", false, null);
            }
            // Implementing multi line insertText ( incase of paste)
            if (text) {
                var multiLines = text.split("\r\n"); // split by CR + LF
                var textNode;
                for (var index = 0;
                     index < multiLines.length;
                     index++) {
                    textNode = composer.selection.doc.createTextNode(multiLines[index]);
                    composer.selection.insertNode(textNode);
                    if (multiLines.length > 1 && index < multiLines.length - 1) {
                        composer.selection.insertNode(composer.selection.doc.createElement("br"));
                    }
                }
                composer.selection.set(textNode, textNode.length);
            }
        }
    },

    state : function () {
        return false;
    }
};
(function (wysihtml5) {
    var NODE_NAME = "IMG";

    wysihtml5.commands.insertImage = {
        /**
         * Inserts an <img>
         * If selection is already an image link, it removes it
         *
         * @example
         *    // either ...
         *    wysihtml5.commands.insertImage.exec(composer, "insertImage", "http://www.google.de/logo.jpg");
         *    // ... or ...
         *    wysihtml5.commands.insertImage.exec(composer, "insertImage", { src: "http://www.google.de/logo.jpg", title: "foo" });
         */
        exec : function (composer, command, value) {
            value = typeof(value) === "object" ? value : {src : value};

            var doc = composer.doc,
                image = this.state(composer),
                textNode,
                i,
                parent;

            if (image) {
                // Image already selected, set the caret before it and delete it
                composer.selection.setBefore(image);
                parent = image.parentNode;
                parent.removeChild(image);

                // and it's parent <a> too if it hasn't got any other relevant child nodes
                wysihtml5.dom.removeEmptyTextNodes(parent);
                if (parent.nodeName === "A" && !parent.firstChild) {
                    composer.selection.setAfter(parent);
                    parent.parentNode.removeChild(parent);
                }

                // firefox and ie sometimes don't remove the image handles, even though the image got removed
                wysihtml5.quirks.redraw(composer.element);
                return;
            }

            image = doc.createElement(NODE_NAME);

            for (i in value) {
                if (i === "className") {
                    i = "class";
                }
                image.setAttribute(i, value[i]);
            }

            composer.selection.insertNode(image);
            if (wysihtml5.browser.hasProblemsSettingCaretAfterImg()) {
                textNode = doc.createTextNode(wysihtml5.INVISIBLE_SPACE);
                composer.selection.insertNode(textNode);
                composer.selection.setAfter(textNode);
            } else {
                composer.selection.setAfter(image);
            }
        },

        state : function (composer) {
            var doc = composer.doc,
                selectedNode,
                text,
                imagesInSelection;

            if (!wysihtml5.dom.hasElementWithTagName(doc, NODE_NAME)) {
                return false;
            }

            selectedNode = composer.selection.getSelectedNode();
            if (!selectedNode) {
                return false;
            }

            if (selectedNode.nodeName === NODE_NAME) {
                // This works perfectly in IE
                return selectedNode;
            }

            if (selectedNode.nodeType !== wysihtml5.ELEMENT_NODE) {
                return false;
            }

            text = composer.selection.getText();
            text = wysihtml5.lang.string(text).trim();
            if (text) {
                return false;
            }

            imagesInSelection = composer.selection.getNodes(wysihtml5.ELEMENT_NODE, function (node) {
                return node.nodeName === "IMG";
            });

            if (imagesInSelection.length !== 1) {
                return false;
            }

            return imagesInSelection[0];
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    var LINE_BREAK = "<br>" + (wysihtml5.browser.needsSpaceAfterLineBreak() ? " " : "");

    wysihtml5.commands.insertLineBreak = {
        exec : function (composer, command) {
            if (composer.commands.support(command)) {
                composer.doc.execCommand(command, false, null);
                if (!wysihtml5.browser.autoScrollsToCaret()) {
                    composer.selection.scrollIntoView();
                }
            } else {
                composer.commands.exec("insertHTML", LINE_BREAK);
            }
        },

        state : function () {
            return false;
        }
    };
})(wysihtml5);
wysihtml5.commands.insertOrderedList = {
    exec : function (composer, command, listType) {
        var doc = composer.doc,
            selectedNode = composer.selection.getSelectedNode(undefined, true),
            list = wysihtml5.dom.getParentElement(selectedNode, {nodeName : "OL"}),
            otherList = wysihtml5.dom.getParentElement(selectedNode, {nodeName : "UL"}),
            tempClassName = "_wysihtml5-temp-" + new Date().getTime(),
            isEmpty,
            tempElement;
        var upperRomanList;
        var lowerRomanList;
        var upperAlphaList;
        var lowerAlphaList;

        //if (!list && !otherList && composer.commands.support(command)) {
        //      doc.execCommand(command, false, null);
        //      return;
        //}

        if (list && (listType == "None")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(list, composer.config.useLineBreaks);
            });
        } else if (otherList && (listType == "None")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(otherList, composer.config.useLineBreaks);
            });
        }

        if (list != null && list.getAttribute("type") == "I") {
            upperRomanList = list;
            list = null;
        }
        if (list != null && list.getAttribute("type") == "i") {
            lowerRomanList = list;
            list = null;
        }
        if (list != null && list.getAttribute("type") == "A") {
            upperAlphaList = list;
            list = null;
        }
        if (list != null && list.getAttribute("type") == "a") {
            lowerAlphaList = list;
            list = null;
        }

        if (list && (listType == "Ordered")) {
            // Unwrap list
            // <ol><li>foo</li><li>bar</li></ol>
            // becomes:
            // foo<br>bar<br>
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(list, composer.config.useLineBreaks);
            });
        } else if (upperRomanList && (listType == "I")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(upperRomanList, composer.config.useLineBreaks);
            });
        } else if (lowerRomanList && (listType == "i")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(lowerRomanList, composer.config.useLineBreaks);
            });
        } else if (upperAlphaList && (listType == "A")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(upperAlphaList, composer.config.useLineBreaks);
            });
        } else if (lowerAlphaList && (listType == "a")) {
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(lowerAlphaList, composer.config.useLineBreaks);
            });
        } else if (otherList) {
            // Turn an unordered list into an ordered list
            // <ul><li>foo</li><li>bar</li></ul>
            // becomes:
            // <ol><li>foo</li><li>bar</li></ol>
            var el = composer.selection.executeAndRestore(function () {
                var element = wysihtml5.dom.renameElement(otherList, "ol");
                var attribute = {};
                attribute.type = listType;
                wysihtml5.dom.setAttributes(attribute).on(element);
            });
            if (el != null && listType != "Ordered") {
                el.setAttribute("type", listType);
            }
        } else if (lowerRomanList || upperRomanList || lowerAlphaList || upperAlphaList) {
            var el = wysihtml5.commands.insertOrderedList.state(composer);
            if (el != null && (listType == "Ordered")) {
                el.removeAttribute("type");
            } else {
                el.setAttribute("type", listType);
            }
        } else if (list) {
            var el = wysihtml5.commands.insertOrderedList.state(composer);
            if (el != null && (listType != "Ordered")) {
                el.setAttribute("type", listType);
            }
        } else if (listType != "None") {
            // Create list
            composer.commands.exec("formatBlock", "div", tempClassName);
            // Check if multiple element are found
            var tempElements = doc.querySelectorAll("." + tempClassName);
            if (tempElements) {
                for (var index = 0;
                     index < tempElements.length;
                     index++) {
                    tempElement = tempElements[index];
                    if (tempElement) {
                        if (index == 0) {
                            composer.selection.executeAndRestore(function () {
                                list = wysihtml5.dom.convertToList(tempElement, "ol", listType);
                            });
                        } else {
                            if (tempElement.nodeName != "LI") {
                                tempElement = wysihtml5.dom.renameElement(tempElement, "li");
                            }
                            wysihtml5.dom.removeClass(tempElement, tempClassName);
                            if (!tempElement.querySelector(wysihtml5.BLOCK_ELEMENTS_GROUP.join(","))) {
                                tempElement.innerHTML = "<p>" + tempElement.innerHTML + "</p>";
                            }
                            if (tempElement) {
                                list.appendChild(tempElement);
                            }
                        }
                        isEmpty = tempElement.innerHTML === "" || tempElement.innerHTML === wysihtml5.INVISIBLE_SPACE || tempElement.innerHTML === "<br>";
                        if (isEmpty) {
                            composer.selection.selectNode(list.querySelector("li"), true);
                        }
                    }
                }
            }
        }
    },

    state : function (composer) {
        var selectedNode = composer.selection.getSelectedNode();
        return wysihtml5.dom.getParentElement(selectedNode, {nodeName : "OL"});
    },

    callbackState : function (composer, command, value, isDefault) {
        var domElem = this.state(composer);
        if (domElem) {
            var attrVal = domElem.getAttribute('type');
            if (attrVal == null && value == 'Ordered') {//when value is 'Ordered', default ordered list numbering is used, no type attribute.
                return true;
            }
            if (attrVal == value) {
                return true;
            }
            return false;
        } else if (isDefault) {         //no domElem with "OL" would be found if we have none type
            return true;
        }
        return false;
    }
};

wysihtml5.commands.insertUnorderedList = {
    exec : function (composer, command) {
        var doc = composer.doc,
            selectedNode = composer.selection.getSelectedNode(undefined, true),
            list = wysihtml5.dom.getParentElement(selectedNode, {nodeName : "UL"}),
            otherList = wysihtml5.dom.getParentElement(selectedNode, {nodeName : "OL"}),
            tempClassName = "_wysihtml5-temp-" + new Date().getTime(),
            isEmpty,
            tempElement;

        if (!list && !otherList && composer.commands.support(command)) {
            doc.execCommand(command, false, null);
            return;
        }

        if (list) {
            // Unwrap list
            // <ul><li>foo</li><li>bar</li></ul>
            // becomes:
            // foo<br>bar<br>
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.resolveList(list, composer.config.useLineBreaks);
            });
        } else if (otherList) {
            // Turn an ordered list into an unordered list
            // <ol><li>foo</li><li>bar</li></ol>
            // becomes:
            // <ul><li>foo</li><li>bar</li></ul>
            composer.selection.executeAndRestore(function () {
                wysihtml5.dom.renameElement(otherList, "ul");
            });
        } else {
            // Create list
            composer.commands.exec("formatBlock", "div", tempClassName);
            var tempElements = doc.querySelectorAll("." + tempClassName);
            if (tempElements) {
                for (var index = 0; index < tempElements.length; index++) {
                    tempElement = tempElements[index];
                    if (tempElement) {
                        if (index == 0) {
                            composer.selection.executeAndRestore(function () {
                                list = wysihtml5.dom.convertToList(tempElement, "ul");
                            });
                        } else {
                            if (tempElement.nodeName != "LI") {
                                tempElement = wysihtml5.dom.renameElement(tempElement, "li");
                            }
                            wysihtml5.dom.removeClass(tempElement, tempClassName);
                            /* Wrap within para tag if no block element present*/
                            if (!tempElement.querySelector(wysihtml5.BLOCK_ELEMENTS_GROUP.join(","))) {
                                tempElement.innerHTML = "<p>" + tempElement.innerHTML + "</p>";
                            }
                            if (tempElement) {
                                list.appendChild(tempElement);
                            }
                        }
                        isEmpty = tempElement.innerHTML === "" || tempElement.innerHTML === wysihtml5.INVISIBLE_SPACE || tempElement.innerHTML === "<br>";
                        if (isEmpty) {
                            composer.selection.selectNode(list.querySelector("li"), true);
                        }
                    }
                }
            }
        }
    },

    state : function (composer) {
        var selectedNode = composer.selection.getSelectedNode();
        return wysihtml5.dom.getParentElement(selectedNode, {nodeName : "UL"});
    },

    callbackState : function (composer) {
        var domElem = this.state(composer);
        if (domElem) {
            return true;
        }
        return false;
    }
};
wysihtml5.commands.italic = {
    exec : function (composer, command) {
        return wysihtml5.commands.formatInline.exec(composer, command, "i");
        //return wysihtml5.commands.formatInline.exec(composer, command, "i");
    },

    state : function (composer, command) {
        // element.ownerDocument.queryCommandState("italic") results:
        // firefox: only <i>
        // chrome:  <i>, <em>, <blockquote>, ...
        // ie:      <i>, <em>
        // opera:   only <i>
        return wysihtml5.commands.formatInline.state(composer, command, "i");
    }
};

(function (wysihtml5) {
    wysihtml5.commands.increaseIndent = {
        exec : function (composer, command) {
            var range = composer.selection.getRange();
            var textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            var attributeValue;
            if (textNodes.length) {
                var textNode;
                for (var i = 0, len = textNodes.length;
                     i < len;
                     ++i) {
                    textNode = textNodes[i];
                    var parent = textNode.parentNode;
                    attributeValue = parent.style["padding-left"];
                    attributeValue = attributeValue.replace(/px/, "");
                    attributeValue = attributeValue.replace(/pt/, "");
                }
            }
            if (attributeValue) {
                var value = parseInt(40) + parseInt(attributeValue);
            }
            value = value + "pt";

            var attributes = {"text-indent" : value};

            return wysihtml5.commands.formatInline.exec(composer, command, "span", "padding-left", /padding-left/g, attributes);
        },

        state : function (composer, command, value) {
            // element.ownerDocument.queryCommandState("italic") results:
            // firefox: only <i>
            // chrome:  <i>, <em>, <blockquote>, ...
            // ie:      <i>, <em>
            // opera:   only <i>
            //return wysihtml5.commands.formatInline.state(composer, command, "span","font-family-"+fontfamily,'/font-family-[0-9a-z]+/g',"font-family",fontfamily);
            value = value + "pt";
            var attributes = {"text-indent" : value};

            return wysihtml5.commands.formatInline.state(composer, command, "span", "padding-left", /padding-left/g, attributes);
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.fontFamily = {
        exec : function (composer, command, fontfamily) {

            var attributes = {"font-family" : fontfamily};

            //return wysihtml5.commands.formatInline.exec(composer, command, "p","font-family-"+fontfamily,/font-family-[0-9a-z]+/g,"font-family",fontfamily);
            return wysihtml5.commands.formatInline.exec(composer, command, "span", "font-family", /font-family/g, attributes);
        },

        state : function (composer, command, fontfamily) {
            // element.ownerDocument.queryCommandState("italic") results:
            // firefox: only <i>
            // chrome:  <i>, <em>, <blockquote>, ...
            // ie:      <i>, <em>
            // opera:   only <i>
            //return wysihtml5.commands.formatInline.state(composer, command, "span","font-family-"+fontfamily,'/font-family-[0-9a-z]+/g',"font-family",fontfamily);
            var attributes = {"font-family" : fontfamily};

            return wysihtml5.commands.formatInline.state(composer, command, "span", "font-family", /font-family/g, attributes);
        },
        callbackState : function (composer, command) {
            var domElem = this.state(composer, command, null);
            var value = [];
            // domElement i.e Selected text nodes exist
            if (domElem && domElem.length) {
                var fontFamily;
                for (var i = 0; i < domElem.length; i++) {
                    // domElement has style attribute
                    if (domElem[i].style) {
                        // getting different font families applied to selected texts
                        fontFamily = domElem[i].style.fontFamily;
                        fontFamily = fontFamily.split(",")[0];
                        fontFamily = fontFamily.replace(/\"/g, "");
                        fontFamily = fontFamily.replace(/'/g, "");
                        // font family is not already retrieved from selected texts, add font family
                        if (!value.includes(fontFamily)) {
                            value.push(fontFamily);
                        }
                    }
                }
            }
            return value;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.customStyle = {
        exec : function (composer, command, classes) {
            var attributes = {"customStyleAttribute" : true};
            var className = " textEditor-customStyle ";
            var REG_EXP = new RegExp(className + "cm-texteditor-customstyle-[a-z]+", "g");
            if (classes) {
                className += classes;
            }
            return wysihtml5.commands.formatInline.exec(composer, command, "span", className, REG_EXP, attributes);
        },

        state : function (composer, command, dataAttribute, clearPreDataAttribute, classes) {
            var attributes = {"customStyleAttribute" : true};
            var className = " textEditor-customStyle ";
            var REG_EXP = new RegExp(className + "cm-texteditor-customstyle-[a-z]+", "g");
            if (classes) {
                className += classes;
            }
            return wysihtml5.commands.formatInline.state(composer, command, "span", className, REG_EXP, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.dataAttribute = {
        exec : function (composer, command, dataAttr, clearPreDataAttribute) {
            var attributes = {"dataAttribute" : true};
            var className = "textEditor-customDataAttr";
            var REG_EXP = new RegExp(className, "g");
            return wysihtml5.commands.formatInline.exec(composer, command, "span", className, REG_EXP, attributes, null, dataAttr, clearPreDataAttribute);
        },

        state : function (composer, command, dataAttribute, clearPreDataAttribute) {
            var attributes = {"dataAttribute" : true};
            var className = "textEditor-customDataAttr";
            var REG_EXP = new RegExp(className, "g");
            return wysihtml5.commands.formatInline.state(composer, command, "span", className, REG_EXP, attributes, null, dataAttribute, clearPreDataAttribute);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.header = {
        exec : function (composer, command, headerType) {
            var className = "textEditor-header-";
            var REG_EXP = new RegExp(className + "[^\s]*", "g");
            className += headerType;
            wysihtml5.commands.formatBlock.exec(composer, command, headerType, className, REG_EXP);
            var domElem = wysihtml5.commands.formatBlock.state(composer, 'lineHeight', headerType);
            wysihtml5.util.clearFontSize(domElem);
            var leading;
            if (domElem && domElem.style && domElem.style.lineHeight) {
                composer.selection.selectNode(domElem);
                var computedStyles = window.getComputedStyle(domElem);
                var maxFontSize = 0;
                if (computedStyles) {
                    maxFontSize = computedStyles.fontSize;
                }
                if (!maxFontSize) {
                    maxFontSize = composer.config.defaultFontSize;
                }
                if (domElem.getAttribute) {
                    leading = (domElem).getAttribute("leading");
                }
                if (!leading) {
                    leading = composer.config.defaultLineHeight;
                }
                var lineHeightValue = parseInt(leading) + parseInt(maxFontSize);
                var attributes = {lineHeight : lineHeightValue, leading : leading};
                // adjusting leading and lineheight depending upon change in fontsize, this is part of fontsize transaction, we won't allow undo for this.
                domElem.style.setProperty("line-height", lineHeightValue + "pt");
                domElem.setAttribute("leading", leading);
            }
        },

        state : function (composer, command, headerType) {
            return wysihtml5.commands.formatBlock.state(composer, command, headerType);
        },
        callbackState : function (composer, command) {
            var domElem = this.state(composer, command, ["P", "H1", "H2", "H3", "H4", "H5", "H6"]);
            var value = "";
            if (domElem && domElem.nodeName) {
                value = domElem.nodeName.toLowerCase();
            }
            return value;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    if (!wysihtml5.helperFn) {
        wysihtml5.helperFn = {};
    }

    wysihtml5.helperFn.getPropertyValue = function (domElem, propertyName) {
        if (domElem && domElem.style) {
            return domElem.style.getPropertyValue(propertyName).replace('pt', '').replace('px', '');
        } else {
            return 0;
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.marginLeft = {
        exec : function (composer, command, value) {
            var marginValue = value + "pt";
            composer.applyStyle(composer, {"margin-left" : marginValue});
        },

        state : function (composer, command, marginValue) {
            if (marginValue) {
                marginValue = marginValue + "pt";
            }
            var attributes = {"margin-left" : marginValue};
            return wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], "margin-left", /margin-left/g, attributes);
        },

        callbackState : function (composer, command, marginValue) {
            var domElem = this.state(composer, command);
            return wysihtml5.helperFn.getPropertyValue(domElem, "margin-left");
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.marginRight = {
        exec : function (composer, command, value) {
            var marginValue = value + "pt";
            composer.applyStyle(composer, {"margin-right" : marginValue});
        },

        state : function (composer, command, marginValue) {
            if (marginValue) {
                marginValue = marginValue + "pt";
            }
            var attributes = {"margin-right" : marginValue};
            return wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], "margin-right", /margin-right/g, attributes);
        },

        callbackState : function (composer, command) {
            var domElem = this.state(composer, command);
            return wysihtml5.helperFn.getPropertyValue(domElem, "margin-right");
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.marginTop = {
        exec : function (composer, command, value) {
            var marginValue = value + "pt";
            composer.applyStyle(composer, {"margin-top" : marginValue});
        },

        state : function (composer, command, marginValue) {
            if (marginValue) {
                marginValue = marginValue + "pt";
            }
            var attributes = {"margin-top" : marginValue};
            return wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], "margin-top", /margin-top/g, attributes);
        },

        callbackState : function (composer, command) {
            var domElem = this.state(composer, command);
            return wysihtml5.helperFn.getPropertyValue(domElem, "margin-top");
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.marginBottom = {
        exec : function (composer, command, value) {
            var marginValue = value + "pt";
            composer.applyStyle(composer, {"margin-bottom" : marginValue});
        },

        state : function (composer, command, marginValue) {
            if (marginValue) {
                marginValue = marginValue + "pt";
            }
            var attributes = {"margin-bottom" : marginValue};
            return wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], "margin-bottom", /margin-bottom/g, attributes);
        },

        callbackState : function (composer, command, marginValue) {
            var domElem = this.state(composer, command, null);
            return wysihtml5.helperFn.getPropertyValue(domElem, "margin-bottom");
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.letterSpacing = {
        exec : function (composer, command, val) {
            val = val + "pt";
            var attributes = {"letter-spacing" : val};

            return wysihtml5.commands.formatInline.exec(composer, command, "span", "letter-spacing", /letter-spacing/g, attributes);
        },

        state : function (composer, command, val) {
            if (val) {
                val = val + "pt";
            }
            var attributes = {"letter-spacing" : val};
            return wysihtml5.commands.formatInline.state(composer, command, "span", "letter-spacing", /letter-spacing/g, attributes);
        },

        callbackState : function (composer, command) {
            var domElem = this.state(composer, command, null);
            var value = "";
            if (domElem) {
                value = wysihtml5.helperFn.getPropertyValue(domElem[0], "letter-spacing");
            }
            return value;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.lineHeight = {
        exec : function (composer, command, attributes) {
            var lineHeightValue = attributes.lineHeight;
            lineHeightValue = lineHeightValue + "pt";
            var leadingValue = attributes.leading;
            composer.applyStyle(composer, {"line-height" : lineHeightValue}, {"leading" : leadingValue});
        },
        state : function (composer, command, val) {
            if (val) {
                val = val + "pt";
            }
            var attributes = {"line-height" : val};
            return wysihtml5.commands.formatBlock.state(composer, command, "p", "line-height", /line-height/g, attributes);
        },
        callbackState : function (composer, command) {
            var domElem = this.state(composer, command, null);
            var value = "";
            if (domElem) {
                value = (domElem).getAttribute("leading");
            }
            return value;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.outdent = {
        exec : function (composer, command, alignValue) {
            if (composer.commands.support(command)) {
                composer.doc.execCommand(command, false, '0pt 5pt 0pt 0pt');
            }
        },

        state : function (composer, command, alignValue) {
            return false;
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.justifyLeft = {
        exec : function (composer, command) {
            composer.applyStyle(composer, {"text-align" : "left"});
        },

        state : function (composer, command) {
            var attributes = {"text-align" : "left"};

            return wysihtml5.commands.formatBlock.state(composer, command, "p", "text-align", /text-align/g, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.justifyCenter = {
        exec : function (composer, command) {
            composer.applyStyle(composer, {"text-align" : "center"});
        },

        state : function (composer, command) {
            var attributes = {"text-align" : "center"};

            return wysihtml5.commands.formatBlock.state(composer, command, "p", "text-align", /text-align/g, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.justifyFull = {
        exec : function (composer, command) {

            composer.applyStyle(composer, {"text-align" : "justify"});
        },

        state : function (composer, command) {
            var attributes = {"text-align" : "justify"};

            return wysihtml5.commands.formatBlock.state(composer, command, "p", "text-align", /text-align/g, attributes);
        }
    };
})(wysihtml5);
(function (wysihtml5) {
    wysihtml5.commands.justifyRight = {
        exec : function (composer, command) {

            composer.applyStyle(composer, {"text-align" : "right"});
        },

        state : function (composer, command) {
            var attributes = {"text-align" : "right"};
            return wysihtml5.commands.formatBlock.state(composer, command, "p", "text-align", /text-align/g, attributes);
        }
    };
})(wysihtml5);

wysihtml5.util = {};
//For fixing LC-3911955
wysihtml5.util.clearFontSize = function (element) {
    if (element && element.childElementCount > 0) {
        for (var ele, index = 0;
             index < element.childElementCount;
             index++) {
            ele = element.children[index];
            if (ele && ele.style) {
                ele.style.setProperty("font-size", "");
            }
            if (ele.childElementCount > 0) {
                wysihtml5.util.clearFontSize(ele);
            }
        }
    }
};

wysihtml5.util.isEditorNode = function (node) {
    return node && node.nodeName.toLowerCase() == "div" && node.classList.contains("wysihtml5-editor");
};

wysihtml5.util.changeLineHeight = function (leading, allowUndo, nodeName, composer, forceApply) {
    if (leading == undefined) {
        leading = composer.config.defaultLineHeight;
    }
    if (allowUndo == undefined) {
        allowUndo = true;
    }
    if (nodeName == undefined) {
        nodeName = "P";
    }
    var selection = composer.selection;
    var currentSelection = selection.getRange();
    if (!currentSelection && forceApply) {// Fixing LC-3911994
        selection.setSelection(selection.editor.savedSelection);
        currentSelection = selection.getRange();
    }
    if (!currentSelection) {
        window.console.log("This error is due to changeLineHeight function.");
        return;
    }
    /* find the maxmimum fontSize in a paragraph, as lineheight is a block level attribute, need to find the maximum font-size before calculating new line height*/
    var matchingSet = {nodeName : nodeName};
    var selectedTextArr = selection.getNodes(3);
    var that = this;
    selectedTextArr.forEach(function (text) {
        var parentParagraph = wysihtml5.dom.getParentElement(text, matchingSet);
        if (!parentParagraph) {
            return;
        }
        if ((parentParagraph && parentParagraph.style && parentParagraph.style.lineHeight) || forceApply) {
            selection.selectNode(parentParagraph);
            var fontSizeSpanArr = wysihtml5.commands.fontSize.state(composer, "fontSize");
            fontSizeSpanArr = [].concat(fontSizeSpanArr);   // getCommandState sometimes can return a single span or an array, forcefully converting into an array
            var maxFontSize = 0;
            fontSizeSpanArr.forEach(function (span) {
                if (span && span.style && span.style.fontSize) {
                    var fontSize = span.style.fontSize.replace("/px/", "");
                    fontSize = fontSize.replace("/pt/", "");
                    fontSize = parseInt(fontSize);
                    maxFontSize = Math.max(fontSize, maxFontSize);
                }
            });

            if (maxFontSize == 0) {
                maxFontSize = composer.config.defaultFontSize;
            }
            var lineHeightValue = parseInt(leading) + parseInt(maxFontSize);
            var attributes = {lineHeight : lineHeightValue, leading : leading};
            // adjusting leading and lineheight depending upon change in fontsize, this is part of fontsize transaction, we won't allow undo for this.
            wysihtml5.commands.lineHeight.exec(composer, "lineHeight", attributes, allowUndo);
        }
    });
    selection.setSelection(currentSelection);
};
wysihtml5.util.getTextNodes = function (selection) {
    var textNodes = selection.getNodes(wysihtml5.TEXT_NODE);
    if (textNodes.length == 0) {
        var node = selection.getSelectedNode();
        if (node.nodeType == wysihtml5.TEXT_NODE) {
            textNodes.push(node);
        }
    }
    return textNodes;
};

wysihtml5.util.getLINodesFromTextNodes = function (textNodes) {
    var liNodes = [];
    for (var i = 0;
         i < textNodes.length;
         ++i) {
        var liParent = wysihtml5.dom.getParentElement(textNodes[i], {nodeName : "LI"});
        if (liParent) {
            liNodes.push(liParent);
        }
    }
    return liNodes;
};

wysihtml5.util.setIndent = function (node) {
    var margin = node.style.marginLeft;
    margin = margin.replace('px', '').replace('pt', '');
    var newMargin = (parseInt(margin) + 40) + 'pt';
    if (margin == "") {
        newMargin = '40pt';
    }
    node.style.marginLeft = newMargin;
};
wysihtml5.util.decreaseIndent = function (node) {
    var margin = node.style.marginLeft;
    margin = margin.replace('px', '').replace('pt', '');
    var newMargin = (parseInt(margin) - 40) + 'pt';
    node.style.marginLeft = newMargin;
};

wysihtml5.util.getImmediateChildsByTagName = function (node, tagNames) {
    var listChilds = [];
    if (node && node.children) {
        for (var i = 0;
             i < node.children.length;
             ++i) {
            if (tagNames.indexOf(node.children[i].nodeName) != -1) {
                listChilds.push(node.children[i]);
            }
        }
    }
    return listChilds;
};

wysihtml5.util.getObjectProperty = function (object, path, defaultValue) {
    var currObject = object;
    if (path) {
        var props = path.split(".");
        props.forEach(function (prop) {
            if (currObject && currObject.hasOwnProperty(prop)) {
                currObject = currObject[prop];
            } else {
                currObject = undefined;
            }
        });
    } else {
        currObject = undefined;
    }
    if (currObject) {
        return currObject;
    } else {
        return defaultValue;
    }
};

(function (wysihtml5) {
    wysihtml5.commands.outdent = {
        exec : function (composer, command, alignValue) {

            var range = composer.selection.getRange();

            // Make sure that selection contains list of only one level, don't do anything in case of multi level*/
            var startContainerParentList = wysihtml5.dom.getParentElement(range.startContainer, {nodeName : ["OL", "UL"]});
            var endContainerParentList = wysihtml5.dom.getParentElement(range.endContainer, {nodeName : ["OL", "UL"]});
            if (startContainerParentList && startContainerParentList != endContainerParentList) {
                return;
            }

            if (startContainerParentList && startContainerParentList.style && (startContainerParentList.style.marginLeft && startContainerParentList.style.marginLeft != "0px" && startContainerParentList.style.marginLeft != "0pt")) {
                wysihtml5.util.decreaseIndent(startContainerParentList);
                composer.selection.selectNode(startContainerParentList);
                return;
            } else if (!startContainerParentList) {
                var nodes = composer.selection ? composer.selection.getNodes(1) : [];
                if (!nodes || nodes.length == 0) {
                    nodes = wysihtml5.util.getTextNodes(composer.selection);
                }
                if (nodes) {
                    for (var i = 0;
                         i < nodes.length;
                         ++i) {
                        if (nodes[i] != null) {
                            var parentNode = nodes[i].parentNode;
                            if (nodes.indexOf(parentNode) < 0) {
                                var para = wysihtml5.dom.getParentElement(nodes[i], {nodeName : ["P", "OL", "UL", "DIV", "H1", "H2", "H3", "H4", "H5", "H6"]});
                                if (para && para.style && para.style.marginLeft != undefined && (para.style.marginLeft != 0 && para.style.marginLeft != "0px" && para.style.marginLeft != "0pt")) {
                                    wysihtml5.util.decreaseIndent(para);
                                }
                            }
                        }
                    }
                }
                return;
            }

            if (composer.commands.support(command)) {
                composer.doc.execCommand(command, false, '0pt 5pt 0pt 0pt');
            }

            var liNodes = wysihtml5.util.getLINodesFromTextNodes(wysihtml5.util.getTextNodes(composer.selection));

            for (var i = liNodes.length - 1;
                 i >= 0;
                 --i) {
                var parentList = wysihtml5.dom.getParentElement(liNodes[i], {nodeName : ["OL", "UL"]});
                if (parentList && liNodes[i].parentElement && liNodes[i].parentElement.nodeName == 'LI') {
                    if (liNodes[i].parentElement.nextSibling) {
                        parentList.insertBefore(liNodes[i], liNodes[i].parentElement.nextSibling);
                    } else {
                        parentList.appendChild(liNodes[i]);
                    }
                }
                composer.selection.selectNode(parentList);
            }
        },

        state : function (composer, command, alignValue) {
            return false;
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.indent = {
        exec : function (composer, command, alignValue) {

            var range = composer.selection.getRange();
            var startContainerParentList = wysihtml5.dom.getParentElement(range.startContainer, {nodeName : ["OL", "UL"]});
            if (startContainerParentList) {
                var startContainerParentListElement = wysihtml5.dom.getParentElement(range.startContainer, {nodeName : "LI"});
                /* we want to insert the new OL/UL elements after indent into the sibling before,
                 in case first element is selected too, we won't have any sibling to insert new OL/UL elements into.
                 if selection contains first element of the list,select whole list and indent*/
                if ((startContainerParentListElement && startContainerParentList.firstChild == startContainerParentListElement) || range.startContainer.nodeName == "OL") {
                    composer.selection.selectNode(startContainerParentList);
                    // apply style on this, margin-left : 40px and return
                    if (startContainerParentList.style && startContainerParentList.style.marginLeft != undefined) {
                        wysihtml5.util.setIndent(startContainerParentList);
                    }
                    return;
                }
            }

            // Make sure that selection contains list of only one level, don't do anything in case of multi level*/
            var startContainerParentList = wysihtml5.dom.getParentElement(range.startContainer, {nodeName : ["OL", "UL"]}),
                indentType;
            if (startContainerParentList) {
                indentType = startContainerParentList.getAttribute("type");
            }
            var endContainerParentList = wysihtml5.dom.getParentElement(range.endContainer, {nodeName : ["OL", "UL"]});
            if (startContainerParentList && startContainerParentList == endContainerParentList) {
                var liNodes = wysihtml5.util.getLINodesFromTextNodes(wysihtml5.util.getTextNodes(composer.selection));
                if (liNodes.length > 0) {
                    var targetListNode = liNodes[0].previousSibling;
                    if (targetListNode) {
                        var listChilds = wysihtml5.util.getImmediateChildsByTagName(targetListNode, ["OL", "UL"]);
                        for (var i = 0;
                             i < liNodes.length;
                             ++i) {
                            if (listChilds.length > 0) {
                                listChilds[0].appendChild(liNodes[i]);
                            } else {
                                var newList = document.createElement(startContainerParentList.nodeName);
                                newList.setAttribute("type", indentType);
                                newList.appendChild(liNodes[i]);        // i must be 0 here.
                                targetListNode.appendChild(newList);
                                listChilds[0] = newList;
                            }
                        }
                    } else {
                        wysihtml5.util.setIndent(startContainerParentList);
                    }
                    composer.selection.selectNode(startContainerParentList);
                }
            } else if (!startContainerParentList) {
                var nodes = composer.selection ? composer.selection.getNodes(1) : [];
                if (!nodes || nodes.length == 0) {
                    nodes = wysihtml5.util.getTextNodes(composer.selection);
                }
                if (nodes) {
                    for (var i = 0;
                         i < nodes.length;
                         ++i) {
                        if (nodes[i] != null) {
                            var parentNode = nodes[i].parentNode;
                            if (nodes.indexOf(parentNode) < 0) {
                                var para = wysihtml5.dom.getParentElement(nodes[i], {nodeName : ["P", "OL", "UL", "DIV", "H1", "H2", "H3", "H4", "H5", "H6"]});
                                if (para && para.style && para.style.marginLeft != undefined) {
                                    wysihtml5.util.setIndent(para);
                                }
                            }
                        }
                    }
                }
            }
        },

        state : function (composer, command, alignValue) {
            return false;
        }
    };
})(wysihtml5);

(function (wysihtml5) {
    wysihtml5.commands.pageBreak = {
        exec : function (composer, command) {
            var range = composer.selection.getRange();
            var textNodes;
            if (range) {
                textNodes = range.getNodes([wysihtml5.TEXT_NODE]);
            }
            /* Fallback in case the text is not selected but cursor is focused on the text*/
            if (textNodes == null || textNodes.length == 0) {
                var selectedNode = composer.selection.getSelectedNode();
                if (selectedNode) {
                    textNodes = [selectedNode];
                }
            }
            if (textNodes.length) {
                var textNode;
                for (var i = 0, len = textNodes.length;
                     i < len;
                     ++i) {
                    textNode = textNodes[i];
                    var parent = wysihtml5.dom.getParentElement(textNode, {nodeName : ["P", "H1", "H2", "H3", "H4", "H5", "H6"]});
                    if (parent) {
                        var styleAttribute = parent.getAttribute("style");
                        if (styleAttribute) {
                            var regExp1 = /page-break-inside\s*:\s*avoid;/g,
                                regExp2 = /page-break-inside\s*:\s*avoid/g; //Check for both with/without semi-colon
                            if (regExp1.exec(styleAttribute)) {
                                styleAttribute = styleAttribute.replace(regExp1, "");
                            } else if (regExp2.exec(styleAttribute)) {
                                styleAttribute = styleAttribute.replace(regExp2, "");
                            } else {
                                if (!styleAttribute.endsWith(";")) {
                                    styleAttribute += ";";
                                }
                                styleAttribute += "page-break-inside: avoid;";
                            }
                        } else {
                            styleAttribute = "page-break-inside: avoid;";
                        }
                        parent.setAttribute("style", styleAttribute);
                    }
                }
            }
        },

        state : function (composer, command) {
            var attributes = {"page-break-inside" : "avoid",
                "break-inside" : "avoid"};
            return !wysihtml5.commands.formatBlock.state(composer, command, ["P", "LI", "H1", "H2", "H3", "H4", "H5", "H6"], null, null, attributes);
        }
    };
})(wysihtml5);
wysihtml5.commands.hiliteColor = {
    exec : function (composer, command, color) {
        /* After state implementation changes, use following browser command.
         if (composer.commands.support(command)) {
         composer.doc.execCommand(command, false, color);
         }*/
        var attributes = {"background-color" : color};
        return wysihtml5.commands.formatInline.exec(composer, command, "span", "wysiwyg-bgcolor-" + color, /wysiwyg-bgcolor-[0-9a-z]+/g, attributes);
    },

    state : function (composer, command, color) {
        var attributes = {"background-color" : color};
        return wysihtml5.commands.formatInline.state(composer, command, "span", "wysiwyg-bgcolor-" + color, /wysiwyg-bgcolor-[0-9a-z]+/g, attributes);
    }
};
wysihtml5.commands.redo = {
    exec : function (composer) {
        return composer.undoManager.redo();
    },

    state : function (composer) {
        return false;
    }
};
wysihtml5.commands.underline = {
    exec : function (composer, command) {
        return wysihtml5.commands.formatInline.exec(composer, command, "u");
    },

    state : function (composer, command) {
        return wysihtml5.commands.formatInline.state(composer, command, "u");
    }
};
wysihtml5.commands.undo = {
    exec : function (composer) {
        return composer.undoManager.undo();
    },

    state : function (composer) {
        return false;
    }
};
/**
 * Undo Manager for wysihtml5
 * slightly inspired by http://rniwa.com/editing/undomanager.html#the-undomanager-interface
 */
(function (wysihtml5) {
    var Z_KEY = 90,
        Y_KEY = 89,
        BACKSPACE_KEY = 8,
        DELETE_KEY = 46,
        MAX_HISTORY_ENTRIES = 25,
        DATA_ATTR_NODE = "data-wysihtml5-selection-node",
        DATA_ATTR_OFFSET = "data-wysihtml5-selection-offset",
        UNDO_HTML = '<span id="_wysihtml5-undo" class="_wysihtml5-temp">' + wysihtml5.INVISIBLE_SPACE + '</span>',
        REDO_HTML = '<span id="_wysihtml5-redo" class="_wysihtml5-temp">' + wysihtml5.INVISIBLE_SPACE + '</span>',
        dom = wysihtml5.dom;

    function cleanTempElements(doc) {
        var tempElement;
        while (tempElement = doc.querySelector("._wysihtml5-temp")) {
            tempElement.parentNode.removeChild(tempElement);
        }
    }

    wysihtml5.UndoManager = wysihtml5.lang.Dispatcher.extend(
        /** @scope wysihtml5.UndoManager.prototype */ {
            constructor : function (editor) {
                this.editor = editor;
                this.composer = editor.composer;
                this.element = this.composer.element;

                this.position = 0;
                this.historyStr = [];
                this.historyDom = [];

                this.transact();

                this._observe();
            },
            clearHistory : function () {
                this.position = 0;
                this.historyStr = [];
                this.historyDom = [];
            },

            _observe : function () {
                var that = this,
                    doc = this.composer.sandbox.getDocument(),
                    lastKey;

                // Catch CTRL+Z and CTRL+Y
                dom.observe(this.element, "keydown", function (event) {
                    if (event.altKey || (!event.ctrlKey && !event.metaKey)) {
                        return;
                    }

                    var keyCode = event.keyCode,
                        isUndo = keyCode === Z_KEY && !event.shiftKey,
                        isRedo = (keyCode === Z_KEY && event.shiftKey) || (keyCode === Y_KEY);

                    if (isUndo) {
                        that.undo();
                        event.preventDefault();
                    } else if (isRedo) {
                        that.redo();
                        event.preventDefault();
                    }
                });

                // Catch delete and backspace
                dom.observe(this.element, "keydown", function (event) {
                    var keyCode = event.keyCode;
                    if (keyCode === lastKey) {
                        return;
                    }

                    lastKey = keyCode;

                    if (keyCode === BACKSPACE_KEY || keyCode === DELETE_KEY) {
                        that.transact();
                    }
                });

                // Now this is very hacky:
                // These days browsers don't offer a undo/redo event which we could hook into
                // to be notified when the user hits undo/redo in the contextmenu.
                // Therefore we simply insert two elements as soon as the contextmenu gets opened.
                // The last element being inserted will be immediately be removed again by a exexCommand("undo")
                //  => When the second element appears in the dom tree then we know the user clicked "redo" in the context menu
                //  => When the first element disappears from the dom tree then we know the user clicked "undo" in the context menu
                if (wysihtml5.browser.hasUndoInContextMenu()) {
                    var interval, observed, cleanUp = function () {
                        cleanTempElements(doc);
                        clearInterval(interval);
                    };

                    dom.observe(this.element, "contextmenu", function () {
                        cleanUp();
                        that.composer.selection.executeAndRestoreSimple(function () {
                            if (that.element.lastChild) {
                                that.composer.selection.setAfter(that.element.lastChild);
                            }

                            // enable undo button in context menu
                            doc.execCommand("insertHTML", false, UNDO_HTML);
                            // enable redo button in context menu
                            doc.execCommand("insertHTML", false, REDO_HTML);
                            doc.execCommand("undo", false, null);
                        });

                        interval = setInterval(function () {
                            if (doc.getElementById("_wysihtml5-redo")) {
                                cleanUp();
                                that.redo();
                            } else if (!doc.getElementById("_wysihtml5-undo")) {
                                cleanUp();
                                that.undo();
                            }
                        }, 400);

                        if (!observed) {
                            observed = true;
                            dom.observe(document, "mousedown", cleanUp);
                            dom.observe(doc, ["mousedown", "paste", "cut", "copy"], cleanUp);
                        }
                    });
                }

                this.editor
                    .on("newword:composer", function () {
                        that.transact();
                    })

                    .on("beforecommand:composer", function () {
                        that.transact();
                    });
            },

            transact : function () {
                var previousHtml = this.historyStr[this.position - 1],
                    currentHtml = this.composer.getValue();

                if (currentHtml === previousHtml) {
                    return;
                }

                var length = this.historyStr.length = this.historyDom.length = this.position;
                if (length > MAX_HISTORY_ENTRIES) {
                    this.historyStr.shift();
                    this.historyDom.shift();
                    this.position--;
                }

                this.position++;

                var range = this.composer.selection.getRange(),
                    node = range.startContainer || this.element,
                    offset = range.startOffset || 0,
                    element,
                    position;

                if (node.nodeType === wysihtml5.ELEMENT_NODE) {
                    element = node;
                } else {
                    element = node.parentNode;
                    position = this.getChildNodeIndex(element, node);
                }

                element.setAttribute(DATA_ATTR_OFFSET, offset);
                if (typeof(position) !== "undefined") {
                    element.setAttribute(DATA_ATTR_NODE, position);
                }

                var clone = this.element.cloneNode(!!currentHtml);
                this.historyDom.push(clone);
                this.historyStr.push(currentHtml);

                element.removeAttribute(DATA_ATTR_OFFSET);
                element.removeAttribute(DATA_ATTR_NODE);
            },

            undo : function () {
                this.transact();

                if (!this.undoPossible()) {
                    return;
                }

                this.set(this.historyDom[--this.position - 1]);
                this.editor.fire("undo:composer");
            },

            redo : function () {
                if (!this.redoPossible()) {
                    return;
                }

                this.set(this.historyDom[++this.position - 1]);
                this.editor.fire("redo:composer");
            },

            undoPossible : function () {
                return this.position > 1;
            },

            redoPossible : function () {
                return this.position < this.historyStr.length;
            },

            set : function (historyEntry) {
                this.element.innerHTML = "";

                var i = 0,
                    childNodes = historyEntry.childNodes,
                    length = historyEntry.childNodes.length;

                for (;
                    i < length;
                    i++) {
                    this.element.appendChild(childNodes[i].cloneNode(true));
                }

                // Restore selection
                var offset,
                    node,
                    position;

                if (historyEntry.hasAttribute(DATA_ATTR_OFFSET)) {
                    offset = historyEntry.getAttribute(DATA_ATTR_OFFSET);
                    position = historyEntry.getAttribute(DATA_ATTR_NODE);
                    node = this.element;
                } else {
                    node = this.element.querySelector("[" + DATA_ATTR_OFFSET + "]") || this.element;
                    offset = node.getAttribute(DATA_ATTR_OFFSET);
                    position = node.getAttribute(DATA_ATTR_NODE);
                    node.removeAttribute(DATA_ATTR_OFFSET);
                    node.removeAttribute(DATA_ATTR_NODE);
                }

                if (position !== null) {
                    node = this.getChildNodeByIndex(node, +position);
                }

                this.composer.selection.set(node, offset);
            },

            getChildNodeIndex : function (parent, child) {
                var i = 0,
                    childNodes = parent.childNodes,
                    length = childNodes.length;
                for (;
                    i < length;
                    i++) {
                    if (childNodes[i] === child) {
                        return i;
                    }
                }
            },

            getChildNodeByIndex : function (parent, index) {
                return parent.childNodes[index];
            }
        });
})(wysihtml5);
/**
 * TODO: the following methods still need unit test coverage
 */
wysihtml5.views.View = Base.extend(
    /** @scope wysihtml5.views.View.prototype */ {
        constructor : function (parent, textareaElement, config) {
            this.parent = parent;
            this.element = textareaElement;
            this.config = config;

            this._observeViewChange();
        },

        _observeViewChange : function () {
            var that = this;
            this.parent.on("beforeload", function () {
                that.parent.on("change_view", function (view) {
                    if (view === that.name) {
                        that.parent.currentView = that;
                        that.show();
                        // Using tiny delay here to make sure that the placeholder is set before focusing
                        setTimeout(function () {
                            that.focus();
                        }, 0);
                    } else {
                        that.hide();
                    }
                });
            });
        },

        focus : function () {
            if (this.element.ownerDocument.querySelector(":focus") === this.element) {
                return;
            }

            try {
                this.element.focus();
            } catch (e) {
            }
        },

        hide : function () {
            this.element.style.display = "none";
        },

        show : function () {
            this.element.style.display = "";
        },

        disable : function () {
            this.element.setAttribute("disabled", "disabled");
        },

        enable : function () {
            this.element.removeAttribute("disabled");
        }
    });
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        browser = wysihtml5.browser;

    wysihtml5.views.Composer = wysihtml5.views.View.extend(
        /** @scope wysihtml5.views.Composer.prototype */ {
            name : "composer",

            // Needed for firefox in order to display a proper caret in an empty contentEditable
            CARET_HACK : "<br>",

            constructor : function (parent, textareaElement, config) {
                this.base(parent, textareaElement, config);
                this.textarea = this.parent.textarea;
                this._initSandbox(config.insertAfter);
            },

            clear : function () {
                this.element.innerHTML = browser.displaysCaretInEmptyContentEditableCorrectly() ? "" : this.CARET_HACK;
            },

            getValue : function (parse) {
                var value = this.isEmpty() ? "" : wysihtml5.quirks.getCorrectInnerHTML(this.element);

                if (parse) {
                    value = this.parent.parse(value);
                }

                // Replace all "zero width no breaking space" chars
                // which are used as hacks to enable some functionalities
                // Also remove all CARET hacks that somehow got left
                value = wysihtml5.lang.string(value).replace(wysihtml5.INVISIBLE_SPACE).by("");

                return value;
            },

            setValue : function (html, parse) {
                if (parse) {
                    html = this.parent.parse(html);
                }

                try {
                    this.element.innerHTML = html;
                } catch (e) {
                    this.element.innerText = html;
                }
            },

            show : function () {
                this.container.style.display = this._displayStyle || "";

                if (!this.textarea.element.disabled) {
                    // Firefox needs this, otherwise contentEditable becomes uneditable
                    this.disable();
                    this.enable();
                }
            },

            hide : function () {
                this._displayStyle = dom.getStyle("display").from(this.container);
                if (this._displayStyle === "none") {
                    this._displayStyle = null;
                }
                this.container.style.display = "none";
            },

            disable : function () {
                this.parent.fire("disable:composer");
                this.element.removeAttribute("contentEditable");
            },

            enable : function () {
                this.parent.fire("enable:composer");
                this.element.setAttribute("contentEditable", "true");
            },

            focus : function (setToEnd) {
                // IE 8 fires the focus event after .focus()
                // This is needed by our simulate_placeholder.js to work
                // therefore we clear it ourselves this time
                if (wysihtml5.browser.doesAsyncFocus() && this.hasPlaceholderSet()) {
                    this.clear();
                }

                this.base();

                var lastChild = this.element.lastChild;
                if (setToEnd && lastChild) {
                    if (lastChild.nodeName === "BR") {
                        this.selection.setBefore(this.element.lastChild);
                    } else {
                        this.selection.setAfter(this.element.lastChild);
                    }
                }
            },

            getTextContent : function () {
                return dom.getTextContent(this.element);
            },

            applyStyle : function (composer, styleProperties, attributes) {
                var selectedNodes = composer.selection.getNodes(1);
                var applyStyleToNode = function (node) {
                    if (node != null) {
                        var parentNode = dom.getParentElement(node, {nodeName : ["LI"]});
                        if (parentNode != null) {
                            /* Prevent applying style to inner lists*/
                            var listNode = dom.getParentElement(node, {nodeName : ["OL", "UL"]});
                            if (listNode != null && selectedNodes.indexOf(listNode) > 0) {
                                var parentListItem = dom.getParentElement(listNode, {nodeName : ["LI"]});
                                if (parentListItem != null && selectedNodes.indexOf(parentListItem) > 0) {
                                    return;
                                }
                            }
                            node = parentNode;
                        }
                        for (var property in styleProperties) {
                            node.style.setProperty(property, styleProperties[property]);
                        }
                        for (var attribute in attributes) {
                            node.setAttribute(attribute, attributes[attribute]);
                        }
                    }
                };
                var nodeList = composer.selection.getNodes(3);
                if (nodeList.length > 0) {
                    for (i = 0;
                         i < nodeList.length;
                         i++) {
                        var node = nodeList[i];
                        if (node != null) {
                            node = node.parentNode;
                            if (node != null && (node.nodeName == "P" || node.nodeName == "LI" || node.nodeName.match(/^H[1-6]$/))) {
                                applyStyleToNode(node);
                            } else if (node != null && !wysihtml5.util.isEditorNode(node)) {
                                while (node != null && node.nodeName != "P" && node.nodeName != "LI" && node.nodeName.match(/^H[1-6]$/) == null) {
                                    node = node.parentElement;
                                }
                                applyStyleToNode(node);
                            }
                        }
                    }
                } else {
                    var selectedNode = composer.selection.getSelectedNode();
                    while (selectedNode != null && selectedNode.nodeName != "P" && selectedNode.nodeName != selectedNode.nodeName.match(/^H[1-6]$/)) {
                        selectedNode = selectedNode.parentElement ? selectedNode.parentElement : selectedNode.parentNode;
                    }
                    applyStyleToNode(selectedNode);
                }
            },
            hasPlaceholderSet : function () {
                return this.getTextContent() == this.textarea.element.getAttribute("placeholder") && this.placeholderSet;
            },

            isEmpty : function () {
                var innerHTML = this.element.innerHTML.toLowerCase();
                return innerHTML === "" ||
                    innerHTML === "<br>" ||
                    innerHTML === "<p></p>" ||
                    innerHTML === "<p><br></p>" ||
                    this.hasPlaceholderSet();
            },

            _initSandbox : function (insertAfter) {

                this.sandbox = new dom.Sandbox({
                    stylesheets : this.config.stylesheets
                });
                this.container = this.sandbox.getContainer();

                var textareaElement = this.textarea.element;
                insertAfter = insertAfter || textareaElement;
                dom.insert(this.container).after(insertAfter);

                // Create hidden field which tells the server after submit, that the user used an wysiwyg editor
                if (textareaElement.form) {
                    var hiddenField = document.createElement("input");
                    hiddenField.type = "hidden";
                    hiddenField.name = "_wysihtml5_mode";
                    hiddenField.value = 1;
                    dom.insert(hiddenField).after(textareaElement);
                }
            },

            _create : function () {
                var that = this;

                this.doc = this.sandbox.getDocument();
                this.element = this.container;
                this.textarea = this.parent.textarea;
                this.element.innerHTML = this.textarea.getValue(true);

                // Make sure our selection handler is ready
                this.selection = new wysihtml5.Selection(this.parent);

                // Make sure commands dispatcher is ready
                this.commands = new wysihtml5.Commands(this.parent);

                dom.copyAttributes([
                    "className", "spellcheck", "title", "lang", "accessKey"
                ]).from(this.textarea.element).to(this.element);

                dom.addClass(this.element, this.config.composerClassName);
                //
                // // Make the editor look like the original textarea, by syncing styles
                if (this.config.style) {
                    this.style();
                }

                this.observe();

                var name = this.config.name;
                if (name) {
                    dom.addClass(this.element, name);
                }

                this.enable();

                if (this.textarea.element.disabled) {
                    this.disable();
                }

                // Simulate html5 placeholder attribute on contentEditable element
                var placeholderText = typeof(this.config.placeholder) === "string" ? this.config.placeholder : this.textarea.element.getAttribute("placeholder");
                if (placeholderText) {
                    dom.simulatePlaceholder(this.parent, this, placeholderText);
                }

                // Make sure that the browser avoids using inline styles whenever possible
                this.commands.exec("styleWithCSS", false);

                this._initAutoLinking();
                this._initObjectResizing();
                this._initUndoManager();
                this._initLineBreaking();

                // Simulate html5 autofocus on contentEditable element
                // This doesn't work on IOS (5.1.1)
                if ((this.textarea.element.hasAttribute("autofocus") || document.querySelector(":focus") == this.textarea.element) && !browser.isIos()) {
                    setTimeout(function () {
                        that.focus(true);
                    }, 100);
                }

                // IE sometimes leaves a single paragraph, which can't be removed by the user
                if (!browser.clearsContentEditableCorrectly()) {
                    wysihtml5.quirks.ensureProperClearing(this);
                }

                // Set up a sync that makes sure that textarea and editor have the same content
                if (this.initSync && this.config.sync) {
                    this.initSync();
                }

                // Okay hide the textarea, we are ready to go
                this.textarea.hide();

                var parent = this.parent;
                // Fire global (before-)load event
                setTimeout(function () {
                    parent.fire("beforeload").fire("load");
                }, 0);
            },

            _initAutoLinking : function () {
                var that = this,
                    supportsDisablingOfAutoLinking = browser.canDisableAutoLinking(),
                    supportsAutoLinking = browser.doesAutoLinkingInContentEditable();
                if (supportsDisablingOfAutoLinking) {
                    this.commands.exec("autoUrlDetect", false);
                }

                if (!this.config.autoLink) {
                    return;
                }

                // Only do the auto linking by ourselves when the browser doesn't support auto linking
                // OR when he supports auto linking but we were able to turn it off (IE9+)
                if (!supportsAutoLinking || (supportsAutoLinking && supportsDisablingOfAutoLinking)) {
                    this.parent.on("newword:composer", function () {
                        if (dom.getTextContent(that.element).match(dom.autoLink.URL_REG_EXP)) {
                            that.selection.executeAndRestore(function (startContainer, endContainer) {
                                dom.autoLink(endContainer.parentNode);
                            });
                        }
                    });

                    dom.observe(this.element, "blur", function () {
                        dom.autoLink(that.element);
                    });
                }

                // Assuming we have the following:
                //  <a href="http://www.google.de">http://www.google.de</a>
                // If a user now changes the url in the innerHTML we want to make sure that
                // it's synchronized with the href attribute (as long as the innerHTML is still a url)
                var // Use a live NodeList to check whether there are any links in the document
                    links = this.sandbox.getDocument().getElementsByTagName("a"),
                    // The autoLink helper method reveals a reg exp to detect correct urls
                    urlRegExp = dom.autoLink.URL_REG_EXP,
                    getTextContent = function (element) {
                        var textContent = wysihtml5.lang.string(dom.getTextContent(element)).trim();
                        if (textContent.substr(0, 4) === "www.") {
                            textContent = "http://" + textContent;
                        }
                        return textContent;
                    };

                dom.observe(this.element, "keydown", function (event) {
                    if (!links.length) {
                        return;
                    }

                    var selectedNode = that.selection.getSelectedNode(event.target.ownerDocument),
                        link = dom.getParentElement(selectedNode, {nodeName : "A"}, 4),
                        textContent;

                    if (!link) {
                        return;
                    }

                    textContent = getTextContent(link);
                    // keydown is fired before the actual content is changed
                    // therefore we set a timeout to change the href
                    setTimeout(function () {
                        var newTextContent = getTextContent(link);
                        if (newTextContent === textContent) {
                            return;
                        }

                        // Only set href when new href looks like a valid url
                        if (newTextContent.match(urlRegExp)) {
                            link.setAttribute("href", newTextContent);
                        }
                    }, 0);
                });
            },

            _initObjectResizing : function () {
                this.commands.exec("enableObjectResizing", true);

                // IE sets inline styles after resizing objects
                // The following lines make sure that the width/height css properties
                // are copied over to the width/height attributes
                if (browser.supportsEvent("resizeend")) {
                    var properties = ["width", "height"],
                        propertiesLength = properties.length,
                        element = this.element;

                    dom.observe(element, "resizeend", function (event) {
                        var target = event.target || event.srcElement,
                            style = target.style,
                            i = 0,
                            property;

                        if (target.nodeName !== "IMG") {
                            return;
                        }

                        for (;
                            i < propertiesLength;
                            i++) {
                            property = properties[i];
                            if (style[property]) {
                                target.setAttribute(property, parseInt(style[property], 10));
                                style[property] = "";
                            }
                        }

                        // After resizing IE sometimes forgets to remove the old resize handles
                        wysihtml5.quirks.redraw(element);
                    });
                }
            },

            _initUndoManager : function () {
                this.undoManager = new wysihtml5.UndoManager(this.parent);
            },

            _initLineBreaking : function () {
                var that = this,
                    USE_NATIVE_LINE_BREAK_INSIDE_TAGS = ["LI", "P", "H1", "H2", "H3", "H4", "H5", "H6"],
                    LIST_TAGS = ["UL", "OL", "MENU"];

                function adjust(selectedNode) {
                    var parentElement = dom.getParentElement(selectedNode, {nodeName : ["P", "DIV", "H1", "H2", "H3", "H4", "H5", "H6"]}, 2);
                    if (parentElement && (parentElement.nodeName == "DIV" || !parentElement.textContent || parentElement.textContent.trim() == "")) {
                        that.selection.executeAndRestore(function () {
                            if (that.config.useLineBreaks) {
                                dom.replaceWithChildNodes(parentElement);
                            } else if (parentElement.nodeName !== "P") {
                                dom.renameElement(parentElement, "p");
                            }
                        });
                    }
                }

                if (!this.config.useLineBreaks) {
                    dom.observe(this.element, ["focus", "keydown"], function () {
                        if (that.isEmpty()) {
                            var paragraph = that.doc.createElement("P");
                            that.element.innerHTML = "";
                            that.element.appendChild(paragraph);
                            var span = that.doc.createElement("span");
                            paragraph.appendChild(span);
                            if (!browser.displaysCaretInEmptyContentEditableCorrectly()) {
                                span.innerHTML = "<br>";
                            }
                            that.selection.selectNode(span, true);
                        }
                    });
                }

                dom.observe(this.element, "keydown", function (event) {
                    var keyCode = event.keyCode;

                    if (event.shiftKey) {
                        return;
                    }

                    if (keyCode !== wysihtml5.ENTER_KEY && keyCode !== wysihtml5.BACKSPACE_KEY) {
                        return;
                    }

                    var blockElement = dom.getParentElement(that.selection.getSelectedNode(), {nodeName : USE_NATIVE_LINE_BREAK_INSIDE_TAGS});

                    if (blockElement) {
                        setTimeout(function () {
                            // Unwrap paragraph after leaving a list or a H1-6
                            var selectedNode = that.selection.getSelectedNode(),
                                list;
                            //Fixing for LC-3910682 : [Text Editor] - New 'help content' symbol gets added when user press enter after a 'help content' symbol
                            // Its hacky method but didnt find who is copying the style & class name on creating new node
                            var className = "textEditor-customDataAttr";
                            if (selectedNode && selectedNode.className && selectedNode.className.indexOf(className) != -1) {
                                selectedNode.className = selectedNode.className.replace(className, "");
                                var data = $(selectedNode).data();
                                for (var key in data) {
                                    $(selectedNode).removeData(key);
                                    $(selectedNode).removeAttr("data-" + key);
                                }
                            }
                            if (that.config && that.config.parserRules && that.config.parserRules.pseudoTags) {
                                var nodeNames = that.config.parserRules.pseudoTags.map(function (tag) {
                                    if (tag) {
                                        return tag.toUpperCase();
                                    }
                                });
                                var pseudoNode = dom.getParentElement(selectedNode, {nodeName : nodeNames});
                                if (pseudoNode && !pseudoNode.textContent) {
                                    pseudoNode.outerHTML = "<span>" + pseudoNode.innerHTML + "</span>";
                                }
                            }

                            if (blockElement.nodeName === "LI") {
                                if (!selectedNode) {
                                    return;
                                }

                                list = dom.getParentElement(selectedNode, {nodeName : LIST_TAGS}, 2);

                                if (!list) {
                                    adjust(selectedNode);
                                }
                            }

                            if (keyCode === wysihtml5.ENTER_KEY && blockElement.nodeName.match(/^H[1-6]$/)) {
                                adjust(selectedNode);
                            }

                            // Refetching the selected node as it may be modifed by adjust
                            selectedNode = that.selection.getSelectedNode();
                            // Make sure that every paragraph & LI have span element
                            var matchingNodes = ["P", "LI", "DIV"];
                            if (selectedNode) {
                                var emptList = [];
                                for (var index = 0;
                                     index < matchingNodes.length;
                                     index++) {
                                    var nodeName = matchingNodes[index];
                                    var tagName = nodeName.toLowerCase();
                                    if (selectedNode.nodeName === nodeName) {
                                        emptList = [];
                                        emptList.push("<" + tagName + "></" + tagName + ">");
                                        emptList.push("<" + tagName + "><br></" + tagName + ">");
                                        emptList.push("<" + tagName + "><br></br></" + tagName + ">");
                                        // check if node is empty ( empty include <br> case also)
                                        if (emptList.indexOf(selectedNode.outerHTML) > -1) {
                                            var span = that.doc.createElement("span");
                                            if (!browser.displaysCaretInEmptyContentEditableCorrectly()) {
                                                span.innerHTML = "<br>";
                                            }
                                            // Remove <BR> if any
                                            while (selectedNode.firstChild) {
                                                selectedNode.removeChild(selectedNode.firstChild);
                                            }
                                            selectedNode.appendChild(span);
                                            if (selectedNode.nodeName === "DIV") {// Make sure we have only P or LI tags
                                                dom.renameElement(selectedNode, "p");
                                            }
                                            that.selection.selectNode(span);// Forcing to focus on span other text will be insert at p or li
                                        }
                                    }
                                }
                                // Make sure that every LI have paragraph+span
                                if (selectedNode) {
                                    var parentLI = dom.getParentElement(selectedNode, {nodeName : "LI"});
                                    var parentDIV = dom.getParentElement(selectedNode, {nodeName : "DIV"});
                                    if (parentLI) {
                                        var childNode;
                                        var para = null;
                                        // Check if fist child node is paragraph : if true simple return or else move the LI content to paragraph
                                        // We are not check all the child as shift enter is used for new Line and it will create span in paragraph
                                        if (parentLI.childElementCount > 0) {
                                            childNode = parentLI.childNodes[0];
                                            if (childNode && childNode.nodeName == "P") {
                                                return;
                                            } else {
                                                para = that.doc.createElement("p");
                                                parentLI.appendChild(para);
                                            }
                                        }
                                        for (var childIndex = 0;
                                             childIndex < parentLI.childElementCount;
                                             childIndex++) {
                                            childNode = parentLI.childNodes[childIndex];
                                            if (para) {
                                                para.appendChild(childNode);
                                            }
                                        }
                                        that.selection.selectNode(childNode);// Forcing to focus on span other text will be insert at p or li
                                    }
                                    if (parentDIV && !wysihtml5.util.isEditorNode(parentDIV)) {
                                        var parsedElem = that.parent.parse(parentDIV);
                                        if (parsedElem.innerHTML) {
                                            parentDIV.outerHTML = parsedElem.innerHTML;
                                        }
                                    }
                                }
                            }
                        }, 0);
                        return;
                    }

                    if (that.config.useLineBreaks && keyCode === wysihtml5.ENTER_KEY && !wysihtml5.browser.insertsLineBreaksOnReturn()) {
                        that.commands.exec("insertLineBreak");
                        event.preventDefault();
                    }
                });
            }
        });
})(wysihtml5);
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        doc = document,
        win = window,
        HOST_TEMPLATE = doc.createElement("div"),
        /**
         * Styles to copy from textarea to the composer element
         */
        TEXT_FORMATTING = [
            "background-color",
            "color", "cursor",
            "font-family", "font-size", "font-style", "font-variant", "font-weight",
            "line-height", "letter-spacing",
            "text-align", "text-decoration", "text-indent", "text-rendering",
            "word-break", "word-wrap", "word-spacing"
        ],
        /**
         * Styles to copy from textarea to the iframe
         */
        BOX_FORMATTING = [
            "background-color",
            "border-collapse",
            "border-bottom-color", "border-bottom-style", "border-bottom-width",
            "border-left-color", "border-left-style", "border-left-width",
            "border-right-color", "border-right-style", "border-right-width",
            "border-top-color", "border-top-style", "border-top-width",
            "clear", "display", "float",
            "margin-bottom", "margin-left", "margin-right", "margin-top",
            "outline-color", "outline-offset", "outline-width", "outline-style",
            "padding-left", "padding-right", "padding-top", "padding-bottom",
            "position", "top", "left", "right", "bottom", "z-index",
            "vertical-align", "text-align",
            "-webkit-box-sizing", "-moz-box-sizing", "-ms-box-sizing", "box-sizing",
            "-webkit-box-shadow", "-moz-box-shadow", "-ms-box-shadow", "box-shadow",
            "-webkit-border-top-right-radius", "-moz-border-radius-topright", "border-top-right-radius",
            "-webkit-border-bottom-right-radius", "-moz-border-radius-bottomright", "border-bottom-right-radius",
            "-webkit-border-bottom-left-radius", "-moz-border-radius-bottomleft", "border-bottom-left-radius",
            "-webkit-border-top-left-radius", "-moz-border-radius-topleft", "border-top-left-radius",
            "width", "height", "white-space"
        ],
        ADDITIONAL_CSS_RULES = [
            "html                 { height: 100%; }",
            "body                 { height: 100%; padding: 1px 0 0 0; margin: -1px 0 0 0; }",
            "body > p:first-child { margin-top: 0; }",
            "._wysihtml5-temp     { display: none; }",
            wysihtml5.browser.isGecko ?
                "body.placeholder { color: graytext !important; }" :
                "body.placeholder { color: #a9a9a9 !important; }",
            // Ensure that user see's broken images and can delete them
            "img:-moz-broken      { -moz-force-broken-image-icon: 1; height: 24px; width: 24px; }"
        ];

    /**
     * With "setActive" IE offers a smart way of focusing elements without scrolling them into view:
     * http://msdn.microsoft.com/en-us/library/ms536738(v=vs.85).aspx
     *
     * Other browsers need a more hacky way: (pssst don't tell my mama)
     * In order to prevent the element being scrolled into view when focusing it, we simply
     * move it out of the scrollable area, focus it, and reset it's position
     */
    var focusWithoutScrolling = function (element) {
        if (element.setActive) {
            // Following line could cause a js error when the textarea is invisible
            // See https://github.com/xing/wysihtml5/issues/9
            try {
                element.setActive();
            } catch (e) {
            }
        } else {
            var elementStyle = element.style,
                originalScrollTop = doc.documentElement.scrollTop || doc.body.scrollTop,
                originalScrollLeft = doc.documentElement.scrollLeft || doc.body.scrollLeft,
                originalStyles = {
                    position : elementStyle.position,
                    top : elementStyle.top,
                    left : elementStyle.left,
                    WebkitUserSelect : elementStyle.WebkitUserSelect
                };

            dom.setStyles({
                position : "absolute",
                top : "-99999px",
                left : "-99999px",
                // Don't ask why but temporarily setting -webkit-user-select to none makes the whole thing performing smoother
                WebkitUserSelect : "none"
            }).on(element);

            element.focus();

            dom.setStyles(originalStyles).on(element);

            if (win.scrollTo) {
                // Some browser extensions unset this method to prevent annoyances
                // "Better PopUp Blocker" for Chrome http://code.google.com/p/betterpopupblocker/source/browse/trunk/blockStart.js#100
                // Issue: http://code.google.com/p/betterpopupblocker/issues/detail?id=1
                win.scrollTo(originalScrollLeft, originalScrollTop);
            }
        }
    };

    wysihtml5.views.Composer.prototype.style = function () {
        var that = this,
            originalActiveElement = doc.querySelector(":focus"),
            textareaElement = this.textarea.element,
            hasPlaceholder = textareaElement.hasAttribute("placeholder"),
            originalPlaceholder = hasPlaceholder && textareaElement.getAttribute("placeholder"),
            originalDisplayValue = textareaElement.style.display,
            originalDisabled = textareaElement.disabled,
            displayValueForCopying;

        this.focusStylesHost = HOST_TEMPLATE.cloneNode(false);
        this.blurStylesHost = HOST_TEMPLATE.cloneNode(false);
        this.disabledStylesHost = HOST_TEMPLATE.cloneNode(false);

        // Remove placeholder before copying (as the placeholder has an affect on the computed style)
        if (hasPlaceholder) {
            textareaElement.removeAttribute("placeholder");
        }

        if (textareaElement === originalActiveElement) {
            textareaElement.blur();
        }

        // enable for copying styles
        textareaElement.disabled = false;

        // set textarea to display="none" to get cascaded styles via getComputedStyle
        textareaElement.style.display = displayValueForCopying = "none";
        textareaElement.style.visibility = "hidden";

        if ((textareaElement.getAttribute("rows") && dom.getStyle("height").from(textareaElement) === "auto") ||
            (textareaElement.getAttribute("cols") && dom.getStyle("width").from(textareaElement) === "auto")) {
            textareaElement.style.display = displayValueForCopying = originalDisplayValue;
        }

        // --------- container styles (has to be set before editor styles, otherwise IE9 sets wrong fontFamily on blurStylesHost) ---------
        dom.copyStyles(BOX_FORMATTING).from(textareaElement).to(this.container).andTo(this.blurStylesHost);

        // --------- editor styles ---------
        dom.copyStyles(TEXT_FORMATTING).from(textareaElement).to(this.element).andTo(this.blurStylesHost);

        // --------- apply standard rules ---------
        dom.insertCSS(ADDITIONAL_CSS_RULES).into(this.element.ownerDocument);

        // --------- :disabled styles ---------
        textareaElement.disabled = true;
        dom.copyStyles(BOX_FORMATTING).from(textareaElement).to(this.disabledStylesHost);
        dom.copyStyles(TEXT_FORMATTING).from(textareaElement).to(this.disabledStylesHost);
        textareaElement.disabled = originalDisabled;

        // --------- :focus styles ---------
        textareaElement.style.display = originalDisplayValue;
        focusWithoutScrolling(textareaElement);
        textareaElement.style.display = displayValueForCopying;

        dom.copyStyles(BOX_FORMATTING).from(textareaElement).to(this.focusStylesHost);
        dom.copyStyles(TEXT_FORMATTING).from(textareaElement).to(this.focusStylesHost);

        // reset textarea
        textareaElement.style.display = originalDisplayValue;

        dom.copyStyles(["display"]).from(textareaElement).to(this.container);

        // Make sure that we don't change the display style of the container when copying styles oblur/onfocus
        // this is needed for when the change_view event is fired where the container is hidden and then
        // the blur event fires and re-displays it
        var boxFormattingStyles = wysihtml5.lang.array(BOX_FORMATTING).without(["display"]);

        // --------- restore focus ---------
        if (originalActiveElement) {
            originalActiveElement.focus();
        } else {
            textareaElement.blur();
        }

        // --------- restore placeholder ---------
        if (hasPlaceholder) {
            textareaElement.setAttribute("placeholder", originalPlaceholder);
        }

        // --------- Sync focus/blur styles ---------

        this.parent.on("blur:composer", function () {
            // Fixing LC-3911994
            this.savedSelection = this.composer.selection.getCurrentRange();
        });

        this.parent.observe("disable:composer", function () {
            dom.copyStyles(boxFormattingStyles).from(that.disabledStylesHost).to(that.container);
            dom.copyStyles(TEXT_FORMATTING).from(that.disabledStylesHost).to(that.element);
        });

        this.parent.observe("enable:composer", function () {
            dom.copyStyles(boxFormattingStyles).from(that.blurStylesHost).to(that.container);
            dom.copyStyles(TEXT_FORMATTING).from(that.blurStylesHost).to(that.element);
        });

        return this;
    };
})(wysihtml5);
/**
 * Taking care of events
 *  - Simulating 'change' event on contentEditable element
 *  - Handling drag & drop logic
 *  - Catch paste events
 *  - Dispatch proprietary newword:composer event
 *  - Keyboard shortcuts
 */
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        browser = wysihtml5.browser,
        /**
         * Map keyCodes to query commands
         */
        shortcuts = {
            "66" : "bold",     // B
            "73" : "italic",   // I
            "85" : "underline" // U
        };

    wysihtml5.views.Composer.prototype.observe = function () {
        var that = this,
            state = this.getValue(),
            container = this.sandbox.getContainer(),
            element = this.element,
            focusBlurElement = browser.supportsEventsInIframeCorrectly() ? element : this.sandbox.getWindow(),
            pasteEvents = ["drop", "paste"];

        // --------- destroy:composer event ---------
        dom.observe(container, "DOMNodeRemoved", function (e) {
            if (e.target == this) { //Destroy composer only if the entire RTE container is removed
                clearInterval(domNodeRemovedInterval);
                that.parent.fire("destroy:composer");
            }
        });

        // DOMNodeRemoved event is not supported in IE 8
        var domNodeRemovedInterval = setInterval(function () {
            if (!dom.contains(document.documentElement, container)) {
                clearInterval(domNodeRemovedInterval);
                that.parent.fire("destroy:composer");
            }
        }, 250);

        // --------- Focus & blur logic ---------
        dom.observe(focusBlurElement, "focus", function () {
            that.parent.fire("focus").fire("focus:composer");

            // Delay storing of state until all focus handler are fired
            // especially the one which resets the placeholder
            setTimeout(function () {
                state = that.getValue();
            }, 0);
        });

        dom.observe(focusBlurElement, "click", function () {
            that.parent.fire("click:composer");
        });

        dom.observe(focusBlurElement, "blur", function () {
            if (state !== that.getValue()) {
                that.parent.fire("change").fire("change:composer");
            }
            that.parent.fire("blur").fire("blur:composer");
        });

        // --------- Drag & Drop logic ---------
        dom.observe(element, "dragenter", function () {
            that.parent.fire("unset_placeholder");
        });

        if (wysihtml5.browser.isIE) {
            dom.observe(element, "beforepaste", function (event) {
                var selection = that.parent.composer.selection.getCurrentRange();
                var tempContainer = $("<div class='wysihtml5-tempContainer' contenteditable='true'></div>")[0];
                document.body.appendChild(tempContainer);
                $(tempContainer).one("paste", function () {
                    event.preventDefault();
                    var content = "";
                    var self = this;
                    setTimeout(function () {
                        if (that.config.pasteAsPlainText) {
                            content = self.textContent;
                        } else {
                            content = self.innerHTML;
                        }
                        content = that.parent.parse(content, true);
                        that.parent.focus(false);
                        that.parent.composer.selection.setSelection(selection);
                        that.commands.exec("delete");
                        that.parent.composer.selection.insertHTML(content);
                        $(self).remove();
                        setTimeout(function () {
                            that.parent.fire("paste").fire("paste:composer", event);
                        }, 0);
                    }, 0);
                });
                tempContainer.focus();
            });

            $(that.parent.composer.doc.defaultView).on('focus', function () {
                var selection = that.parent.composer.doc.getSelection();
                if (!selection || !selection.focusNode) {
                    that.parent.composer.focus(false);
                    if (that.parent.savedSelection) {
                        that.parent.composer.selection.setSelection(that.parent.savedSelection);
                    }
                }
            });
        }

        dom.observe(element, pasteEvents, function (event) {
            if (that.config.pasteAsPlainText) {
                event.preventDefault();
                var content = "";
                if (event && event.clipboardData) {
                    content = (event.originalEvent || event).clipboardData.getData('text/plain');
                } else if (window.clipboardData) {
                    content = window.clipboardData.getData('Text');
                }
                if (content) {
                    that.commands.exec.call(that.commands, "insertText", content);
                }
            } else {
                var html = "";
                if (event && event.clipboardData) {
                    html = (event.originalEvent || event).clipboardData.getData('text/html');
                }
                if (html) {
                    event.preventDefault();
                    if (that.selection.getText()) {
                        that.commands.exec("delete");
                    }

                    /* Extract body content if body present, to remove unwanted data*/
                    var re = XRegExp("<body[^>]*>\\s*(.*)\\s*<\/body>", "gs");
                    var result = re.exec(html);

                    if (result && result.length > 1) {
                        html = result[1];
                    }
                    html = that.parent.parse(html, true);
                    that.parent.composer.selection.insertHTML(html);
                }
                setTimeout(function () {
                    that.parent.fire("paste").fire("paste:composer", event);
                }, 0);
            }
        });

        // --------- neword event ---------
        dom.observe(element, "keyup", function (event) {
            var keyCode = event.keyCode;
            if (keyCode === wysihtml5.SPACE_KEY || keyCode === wysihtml5.ENTER_KEY) {
                that.parent.fire("newword:composer");
            }
        });

        this.parent.on("paste:composer", function () {
            setTimeout(function () {
                that.parent.fire("newword:composer");
            }, 0);
        });

        // --------- Make sure that images are selected when clicking on them ---------
        if (!browser.canSelectImagesInContentEditable()) {
            dom.observe(element, "mousedown", function (event) {
                var target = event.target;
                if (target.nodeName === "IMG") {
                    that.selection.selectNode(target);
                    event.preventDefault();
                }
            });
        }

        if (browser.hasHistoryIssue() && browser.supportsSelectionModify()) {
            dom.observe(element, "keydown", function (event) {
                if (!event.metaKey && !event.ctrlKey) {
                    return;
                }

                var keyCode = event.keyCode,
                    win = element.ownerDocument.defaultView,
                    selection = win.getSelection();

                if (keyCode === 37 || keyCode === 39) {
                    if (keyCode === 37) {
                        selection.modify("extend", "left", "lineboundary");
                        if (!event.shiftKey) {
                            selection.collapseToStart();
                        }
                    }
                    if (keyCode === 39) {
                        selection.modify("extend", "right", "lineboundary");
                        if (!event.shiftKey) {
                            selection.collapseToEnd();
                        }
                    }
                    event.preventDefault();
                }
            });
        }

        // --------- Shortcut logic ---------
        dom.observe(element, "keydown", function (event) {
            var keyCode = event.keyCode,
                command = shortcuts[keyCode];
            if ((event.ctrlKey || event.metaKey) && !event.altKey && command) {
                that.commands.exec(command);
                event.preventDefault();
            }
        });

        /* Handing Tab key : Insert tab into text and prevent losing the focus from textarea. */
        dom.observe(element, "keydown", function (event) {

            if (event.keyCode == wysihtml5.TAB_KEY) {
                that.commands.exec.call(that.commands, "insertText", '\t');
                /* For handling IE */
                if (wysihtml5.browser.hasIframeFocusIssue()) {
                    var target = that.selection ? that.selection.getSelectedNode() : null;
                    if (target) {
                        var parent = target.parentNode;
                        if (parent && parent.style) {
                            parent.style.whiteSpace = "pre";
                        } else {
                            parent.setAttribute("style", "white-space: pre");
                        }
                    }
                }
                event.preventDefault();
            }
        });

        // --------- Make sure that when pressing backspace/delete on selected images deletes the image and it's anchor ---------
        dom.observe(element, "keydown", function (event) {
            var target = that.selection.getSelectedNode(true),
                keyCode = event.keyCode,
                parent;
            if (target && (keyCode === wysihtml5.BACKSPACE_KEY || keyCode === wysihtml5.DELETE_KEY)) {// 8 => backspace, 46 => delete
                var nodeNames = [];
                /* Delete configured text nodes as they are not editable and won't be deleted */
                if (that.config.parserRules && that.config.parserRules.textNodes) {
                    nodeNames = that.config.parserRules.textNodes;
                }
                nodeNames.push("IMG");
                if (nodeNames.indexOf(target.nodeName) > -1) {
                    parent = target.parentNode;
                    parent.removeChild(target);
                    if (target.nodeName === "IMG") {
                        // and it's parent <a> too if it hasn't got any other child nodes
                        if (parent.nodeName === "A" && !parent.firstChild) {
                            parent.parentNode.removeChild(parent);
                        }

                        setTimeout(function () {
                            wysihtml5.quirks.redraw(element);
                        }, 0);
                    }
                    event.preventDefault();
                }
            }
        });

        // --------- IE 8+9 focus the editor when the iframe is clicked (without actually firing the 'focus' event on the <body>) ---------
        if (browser.hasIframeFocusIssue()) {
            dom.observe(this.container, "focus", function () {
                setTimeout(function () {
                    if (that.doc.querySelector(":focus") !== that.element) {
                        that.focus();
                    }
                }, 0);
            });

            dom.observe(this.element, "blur", function () {
                setTimeout(function () {
                    that.selection.getSelection().removeAllRanges();
                }, 0);
            });
        }

        // --------- Show url in tooltip when hovering links or images ---------
        var titlePrefixes = {
            IMG : "Image: ",
            A : "Link: "
        };

        dom.observe(element, "mouseover", function (event) {
            var target = event.target,
                nodeName = target.nodeName,
                title;
            if (nodeName !== "A" && nodeName !== "IMG") {
                return;
            }
            var hasTitle = target.hasAttribute("title");
            if (!hasTitle) {
                title = titlePrefixes[nodeName] + (target.getAttribute("href") || target.getAttribute("src"));
                target.setAttribute("title", title);
            }
        });
    };
})(wysihtml5);
/**
 * Class that takes care that the value of the composer and the textarea is always in sync
 */
(function (wysihtml5) {
    var INTERVAL = 400;

    wysihtml5.views.Synchronizer = Base.extend(
        /** @scope wysihtml5.views.Synchronizer.prototype */ {

            constructor : function (editor, textarea, composer) {
                this.editor = editor;
                this.textarea = textarea;
                this.composer = composer;

                this._observe();
            },

            /**
             * Sync html from composer to textarea
             * Takes care of placeholders
             * @param {Boolean} shouldParseHtml Whether the html should be sanitized before inserting it into the textarea
             */
            fromComposerToTextarea : function (shouldParseHtml) {
                this.textarea.setValue(wysihtml5.lang.string(this.composer.getValue()).trim(), shouldParseHtml);
            },

            /**
             * Sync value of textarea to composer
             * Takes care of placeholders
             * @param {Boolean} shouldParseHtml Whether the html should be sanitized before inserting it into the composer
             */
            fromTextareaToComposer : function (shouldParseHtml) {
                var textareaValue = this.textarea.getValue();
                if (textareaValue) {
                    this.composer.setValue(textareaValue, shouldParseHtml);
                } else {
                    this.composer.clear();
                    this.editor.fire("set_placeholder");
                }
            },

            /**
             * Invoke syncing based on view state
             * @param {Boolean} shouldParseHtml Whether the html should be sanitized before inserting it into the composer/textarea
             */
            sync : function (shouldParseHtml) {
                if (this.editor.currentView.name === "textarea") {
                    this.fromTextareaToComposer(shouldParseHtml);
                } else {
                    this.fromComposerToTextarea(shouldParseHtml);
                }
            },

            /**
             * Initializes interval-based syncing
             * also makes sure that on-submit the composer's content is synced with the textarea
             * immediately when the form gets submitted
             */
            _observe : function () {
                var interval,
                    that = this,
                    form = this.textarea.element.form,
                    startInterval = function () {
                        interval = setInterval(function () {
                            that.fromComposerToTextarea();
                        }, INTERVAL);
                    },
                    stopInterval = function () {
                        clearInterval(interval);
                        interval = null;
                    };

                startInterval();

                if (form) {
                    // If the textarea is in a form make sure that after onreset and onsubmit the composer
                    // has the correct state
                    wysihtml5.dom.observe(form, "submit", function () {
                        that.sync(true);
                    });
                    wysihtml5.dom.observe(form, "reset", function () {
                        setTimeout(function () {
                            that.fromTextareaToComposer();
                        }, 0);
                    });
                }

                this.editor.on("change_view", function (view) {
                    if (view === "composer" && !interval) {
                        that.fromTextareaToComposer(true);
                        startInterval();
                    } else if (view === "textarea") {
                        that.fromComposerToTextarea(true);
                        stopInterval();
                    }
                });

                this.editor.on("destroy:composer", stopInterval);
            }
        });
})(wysihtml5);
wysihtml5.views.Textarea = wysihtml5.views.View.extend(
    /** @scope wysihtml5.views.Textarea.prototype */ {
        name : "textarea",

        constructor : function (parent, textareaElement, config) {
            this.base(parent, textareaElement, config);

            this._observe();
        },

        clear : function () {
            this.element.value = "";
        },

        getValue : function (parse) {
            var value = this.isEmpty() ? "" : this.element.value;
            if (parse && value) {
                value = this.parent.parse(value);
            }
            return value;
        },

        setValue : function (html, parse) {
            if (parse) {
                html = this.parent.parse(html);
            }
            this.element.value = html;
        },

        hasPlaceholderSet : function () {
            var supportsPlaceholder = wysihtml5.browser.supportsPlaceholderAttributeOn(this.element),
                placeholderText = this.element.getAttribute("placeholder") || null,
                value = this.element.value,
                isEmpty = !value;
            return (supportsPlaceholder && isEmpty) || (value === placeholderText);
        },

        isEmpty : function () {
            return !this.element.value || !wysihtml5.lang.string(this.element.value).trim() || this.hasPlaceholderSet();
        },

        _observe : function () {
            var element = this.element,
                parent = this.parent,
                eventMapping = {
                    focusin : "focus",
                    focusout : "blur"
                },
                /**
                 * Calling focus() or blur() on an element doesn't synchronously trigger the attached focus/blur events
                 * This is the case for focusin and focusout, so let's use them whenever possible, kkthxbai
                 */
                events = wysihtml5.browser.supportsEvent("focusin") ? ["focusin", "focusout", "change"] : ["focus", "blur", "change"];

            parent.on("beforeload", function () {
                wysihtml5.dom.observe(element, events, function (event) {
                    var eventName = eventMapping[event.type] || event.type;
                    parent.fire(eventName).fire(eventName + ":textarea");
                });

                wysihtml5.dom.observe(element, ["paste", "drop"], function () {
                    setTimeout(function () {
                        parent.fire("paste").fire("paste:textarea");
                    }, 0);
                });
            });
        }
    });
/**
 * Toolbar Dialog
 *
 * @param {Element} link The toolbar link which causes the dialog to show up
 * @param {Element} container The dialog container
 *
 * @example
 *    <!-- Toolbar link -->
 *    <a data-wysihtml5-command="insertImage">insert an image</a>
 *
 *    <!-- Dialog -->
 *    <div data-wysihtml5-dialog="insertImage" style="display: none;">
 *      <label>
 *        URL: <input data-wysihtml5-dialog-field="src" value="http://">
 *      </label>
 *      <label>
 *        Alternative text: <input data-wysihtml5-dialog-field="alt" value="">
 *      </label>
 *    </div>
 *
 *    <script>
 *      var dialog = new wysihtml5.toolbar.Dialog(
 *        document.querySelector("[data-wysihtml5-command='insertImage']"),
 *        document.querySelector("[data-wysihtml5-dialog='insertImage']")
 *      );
 *      dialog.observe("save", function(attributes) {
 *        // do something
 *      });
 *    </script>
 */
(function (wysihtml5) {
    var dom = wysihtml5.dom,
        CLASS_NAME_OPENED = "wysihtml5-command-dialog-opened",
        SELECTOR_FORM_ELEMENTS = "input, select, textarea",
        SELECTOR_FIELDS = "[data-wysihtml5-dialog-field]",
        ATTRIBUTE_FIELDS = "data-wysihtml5-dialog-field";

    wysihtml5.toolbar.Dialog = wysihtml5.lang.Dispatcher.extend(
        /** @scope wysihtml5.toolbar.Dialog.prototype */ {
            constructor : function (link, container) {
                this.link = link;
                this.container = container;
            },

            _observe : function () {
                if (this._observed) {
                    return;
                }

                var that = this,
                    callbackWrapper = function (event) {
                        var attributes = that._serialize();
                        if (attributes == that.elementToChange) {
                            that.fire("edit", attributes);
                        } else {
                            that.fire("save", attributes);
                        }
                        that.hide();
                        event.preventDefault();
                        event.stopPropagation();
                    };

                dom.observe(that.link, "click", function () {
                    if (dom.hasClass(that.link, CLASS_NAME_OPENED)) {
                        setTimeout(function () {
                            that.hide();
                        }, 0);
                    }
                });

                dom.observe(this.container, "keydown", function (event) {
                    var keyCode = event.keyCode;
                    if (keyCode === wysihtml5.ENTER_KEY) {
                        callbackWrapper(event);
                    }
                    if (keyCode === wysihtml5.ESCAPE_KEY) {
                        that.hide();
                    }
                });

                dom.delegate(this.container, "[data-wysihtml5-dialog-action=save]", "click", callbackWrapper);

                dom.delegate(this.container, "[data-wysihtml5-dialog-action=cancel]", "click", function (event) {
                    that.fire("cancel");
                    that.hide();
                    event.preventDefault();
                    event.stopPropagation();
                });

                var formElements = this.container.querySelectorAll(SELECTOR_FORM_ELEMENTS),
                    i = 0,
                    length = formElements.length,
                    _clearInterval = function () {
                        clearInterval(that.interval);
                    };
                for (;
                    i < length;
                    i++) {
                    dom.observe(formElements[i], "change", _clearInterval);
                }

                this._observed = true;
            },

            /**
             * Grabs all fields in the dialog and puts them in key=>value style in an object which
             * then gets returned
             */
            _serialize : function () {
                var data = this.elementToChange || {},
                    fields = this.container.querySelectorAll(SELECTOR_FIELDS),
                    length = fields.length,
                    i = 0;
                for (;
                    i < length;
                    i++) {
                    data[fields[i].getAttribute(ATTRIBUTE_FIELDS)] = fields[i].value;
                }
                return data;
            },

            /**
             * Takes the attributes of the "elementToChange"
             * and inserts them in their corresponding dialog input fields
             *
             * Assume the "elementToChange" looks like this:
             *    <a href="http://www.google.com" target="_blank">foo</a>
             *
             * and we have the following dialog:
             *    <input type="text" data-wysihtml5-dialog-field="href" value="">
             *    <input type="text" data-wysihtml5-dialog-field="target" value="">
             *
             * after calling _interpolate() the dialog will look like this
             *    <input type="text" data-wysihtml5-dialog-field="href" value="http://www.google.com">
             *    <input type="text" data-wysihtml5-dialog-field="target" value="_blank">
             *
             * Basically it adopted the attribute values into the corresponding input fields
             *
             */
            _interpolate : function (avoidHiddenFields) {
                var field,
                    fieldName,
                    newValue,
                    focusedElement = document.querySelector(":focus"),
                    fields = this.container.querySelectorAll(SELECTOR_FIELDS),
                    length = fields.length,
                    i = 0;
                for (;
                    i < length;
                    i++) {
                    field = fields[i];

                    // Never change elements where the user is currently typing in
                    if (field === focusedElement) {
                        continue;
                    }

                    // Don't update hidden fields
                    // See https://github.com/xing/wysihtml5/pull/14
                    if (avoidHiddenFields && field.type === "hidden") {
                        continue;
                    }

                    fieldName = field.getAttribute(ATTRIBUTE_FIELDS);
                    newValue = this.elementToChange ? (this.elementToChange[fieldName] || "") : field.defaultValue;
                    field.value = newValue;
                }
            },

            /**
             * Show the dialog element
             */
            show : function (elementToChange) {
                if (dom.hasClass(this.link, CLASS_NAME_OPENED)) {
                    return;
                }

                var that = this,
                    firstField = this.container.querySelector(SELECTOR_FORM_ELEMENTS);
                this.elementToChange = elementToChange;
                this._observe();
                this._interpolate();
                if (elementToChange) {
                    this.interval = setInterval(function () {
                        that._interpolate(true);
                    }, 500);
                }
                dom.addClass(this.link, CLASS_NAME_OPENED);
                this.container.style.display = "";
                this.fire("show");
                if (firstField && !elementToChange) {
                    try {
                        firstField.focus();
                    } catch (e) {
                    }
                }
            },

            /**
             * Hide the dialog element
             */
            hide : function () {
                clearInterval(this.interval);
                this.elementToChange = null;
                dom.removeClass(this.link, CLASS_NAME_OPENED);
                this.container.style.display = "none";
                this.fire("hide");
            }
        });
})(wysihtml5);
/**
 * Converts speech-to-text and inserts this into the editor
 * As of now (2011/03/25) this only is supported in Chrome >= 11
 *
 * Note that it sends the recorded audio to the google speech recognition api:
 * http://stackoverflow.com/questions/4361826/does-chrome-have-buil-in-speech-recognition-for-input-type-text-x-webkit-speec
 *
 * Current HTML5 draft can be found here
 * http://lists.w3.org/Archives/Public/public-xg-htmlspeech/2011Feb/att-0020/api-draft.html
 *
 * "Accessing Google Speech API Chrome 11"
 * http://mikepultz.com/2011/03/accessing-google-speech-api-chrome-11/
 */
(function (wysihtml5) {
    var dom = wysihtml5.dom;

    var linkStyles = {
        position : "relative"
    };

    var wrapperStyles = {
        left : 0,
        margin : 0,
        opacity : 0,
        overflow : "hidden",
        padding : 0,
        position : "absolute",
        top : 0,
        zIndex : 1
    };

    var inputStyles = {
        cursor : "inherit",
        fontSize : "50px",
        height : "50px",
        marginTop : "-25px",
        outline : 0,
        padding : 0,
        position : "absolute",
        right : "-4px",
        top : "50%"
    };

    var inputAttributes = {
        "x-webkit-speech" : "",
        "speech" : ""
    };

    wysihtml5.toolbar.Speech = function (parent, link) {
        var input = document.createElement("input");
        if (!wysihtml5.browser.supportsSpeechApiOn(input)) {
            link.style.display = "none";
            return;
        }
        var lang = parent.editor.textarea.element.getAttribute("lang");
        if (lang) {
            inputAttributes.lang = lang;
        }

        var wrapper = document.createElement("div");

        wysihtml5.lang.object(wrapperStyles).merge({
            width : link.offsetWidth + "px",
            height : link.offsetHeight + "px"
        });

        dom.insert(input).into(wrapper);
        dom.insert(wrapper).into(link);

        dom.setStyles(inputStyles).on(input);
        dom.setAttributes(inputAttributes).on(input);

        dom.setStyles(wrapperStyles).on(wrapper);
        dom.setStyles(linkStyles).on(link);

        var eventName = "onwebkitspeechchange" in input ? "webkitspeechchange" : "speechchange";
        dom.observe(input, eventName, function () {
            parent.execCommand("insertText", input.value);
            input.value = "";
        });

        dom.observe(input, "click", function (event) {
            if (dom.hasClass(link, "wysihtml5-command-disabled")) {
                event.preventDefault();
            }

            event.stopPropagation();
        });
    };
})(wysihtml5);
/**
 * Toolbar
 *
 * @param {Object} parent Reference to instance of Editor instance
 * @param {Element} container Reference to the toolbar container element
 *
 * @example
 *    <div id="toolbar">
 *      <a data-wysihtml5-command="createLink">insert link</a>
 *      <a data-wysihtml5-command="formatBlock" data-wysihtml5-command-value="h1">insert h1</a>
 *    </div>
 *
 *    <script>
 *      var toolbar = new wysihtml5.toolbar.Toolbar(editor, document.getElementById("toolbar"));
 *    </script>
 */
(function (wysihtml5) {
    var CLASS_NAME_COMMAND_DISABLED = "wysihtml5-command-disabled",
        CLASS_NAME_COMMANDS_DISABLED = "wysihtml5-commands-disabled",
        CLASS_NAME_COMMAND_ACTIVE = "wysihtml5-command-active",
        CLASS_NAME_ACTION_ACTIVE = "wysihtml5-action-active",
        dom = wysihtml5.dom;

    wysihtml5.toolbar.Toolbar = Base.extend(
        /** @scope wysihtml5.toolbar.Toolbar.prototype */ {
            constructor : function (editor, container) {
                this.editor = editor;
                this.container = typeof(container) === "string" ? document.getElementById(container) : container;
                this.composer = editor.composer;

                if (!this.container.classList.contains("wysihtml5-toolbar")) {
                    this._getLinks("command");
                    this._getLinks("action");

                    this._observe();
                    this.show();

                    var speechInputLinks = this.container.querySelectorAll("[data-wysihtml5-command=insertSpeech]"),
                        length = speechInputLinks.length,
                        i = 0;
                    for (;
                        i < length;
                        i++) {
                        new wysihtml5.toolbar.Speech(this, speechInputLinks[i]);
                    }
                }
                this.container.classList.add("wysihtml5-toolbar");
            },

            _getLinks : function (type) {
                var links = this[type + "Links"] = wysihtml5.lang.array(this.container.querySelectorAll("[data-wysihtml5-" + type + "]")).get(),
                    length = links.length,
                    i = 0,
                    mapping = this[type + "Mapping"] = {},
                    link,
                    group,
                    name,
                    value,
                    dialog;
                for (;
                    i < length;
                    i++) {
                    link = links[i];
                    name = link.getAttribute("data-wysihtml5-" + type);
                    value = link.getAttribute("data-wysihtml5-" + type + "-value");
                    func = link.getAttribute("data-wysihtml5-" + type + "-stateCallbackFn");
                    elementName = link.getAttribute("data-wysihtml5-" + type + "-element");
                    isDefault = link.getAttribute("data-wysihtml5-" + type + "-default");
                    group = this.container.querySelector("[data-wysihtml5-" + type + "-group='" + name + "']");
                    dialog = this._getDialog(link, name);

                    mapping[name + ":" + value] = {
                        link : link,
                        group : group,
                        name : name,
                        func : func,
                        elementName : elementName,
                        isDefault : isDefault == "" ? true : false,
                        value : value,
                        dialog : dialog,
                        state : false
                    };
                }
            },

            _getDialog : function (link, command) {
                var that = this,
                    dialogElement = this.container.querySelector("[data-wysihtml5-dialog='" + command + "']"),
                    dialog,
                    caretBookmark;

                if (dialogElement) {
                    dialog = new wysihtml5.toolbar.Dialog(link, dialogElement);

                    dialog.on("show", function () {
                        caretBookmark = that.composer.selection.getBookmark();

                        that.editor.fire("show:dialog", {
                            command : command,
                            dialogContainer : dialogElement,
                            commandLink : link
                        });
                    });

                    dialog.on("save", function () {
                        if (caretBookmark) {
                            that.composer.selection.setBookmark(caretBookmark);
                        }
                        that._execCommand(command, attributes);
                        that.editor.fire("save:dialog", {
                            command : command,
                            dialogContainer : dialogElement,
                            commandLink : link
                        });
                    });

                    dialog.on("saveOnly", function () {
                        if (caretBookmark) {
                            that.composer.selection.setBookmark(caretBookmark);
                        }
                    });

                    dialog.on("cancel", function () {
                        that.editor.focus(false);
                        that.editor.fire("cancel:dialog", {
                            command : command,
                            dialogContainer : dialogElement,
                            commandLink : link
                        });
                    });
                }
                return dialog;
            },

            /**
             * @example
             *    var toolbar = new wysihtml5.Toolbar();
             *    // Insert a <blockquote> element or wrap current selection in <blockquote>
             *    toolbar.execCommand("formatBlock", "blockquote");
             */
            execCommand : function (command, commandValue) {
                if (this.commandsDisabled) {
                    return;
                }

                var commandObj = this.commandMapping[command + ":" + commandValue];

                // Show dialog when available
                if (commandObj && commandObj.dialog && !commandObj.state) {
                    commandObj.dialog.show();
                } else {
                    this._execCommand(command, commandValue);
                }
            },

            _execCommand : function (command, commandValue) {

                this.composer.commands.exec(command, commandValue);
                this._updateLinkStates();
            },

            execAction : function (action) {
                var editor = this.editor;
                if (action === "change_view") {
                    if (editor.currentView === editor.textarea) {
                        editor.fire("change_view", "composer");
                    } else {
                        editor.fire("change_view", "textarea");
                    }
                }
            },

            _observe : function () {
                var that = this,
                    editor = this.editor,
                    container = this.container,
                    links = this.commandLinks.concat(this.actionLinks),
                    length = links.length,
                    i = 0;

                for (;
                    i < length;
                    i++) {
                    // 'javascript:;' and unselectable=on Needed for IE, but done in all browsers to make sure that all get the same css applied
                    // (you know, a:link {... } doesn't match anchors with missing href attribute)
                    var attributes = {};
                    attributes.href = "javascript:;";
                    if (links[i] && !links[i].hasAttribute("unselectable") && links[i].tagName.toLowerCase() != "input") {
                        attributes.unselectable = "on";
                    }
                    dom.setAttributes(attributes).on(links[i]);
                }

                // Needed for opera and chrome
                dom.delegate(container, "[data-wysihtml5-action]", "mousedown", function (event) {
                    event.preventDefault();
                });

                dom.delegate(container, "[data-wysihtml5-command]", "mousedown", function (event) {
                    var link = this,
                        command = link.getAttribute("data-wysihtml5-command"),
                        commandValue = link.getAttribute("data-wysihtml5-command-value");

                    //To allow default action in case of margin fields.
                    if (!link.hasAttribute("data-wysihtml5-skip")) {
                        event.preventDefault();
                    }
                });

                dom.delegate(container, "[data-wysihtml5-command]", "click", function (event) {
                    var link = this,
                        command = link.getAttribute("data-wysihtml5-command"),
                        commandValue = link.getAttribute("data-wysihtml5-command-value"),
                        form = link.form;
                    if (commandValue === null && form) {
                        commandValue = {};
                        var formInputs = form.querySelectorAll("input[name], textarea[name]");
                        for (var i = 0; i < formInputs.length; i++) {
                            var element = formInputs[i];
                            var value = element.value;
                            if (element.type === "checkbox") {
                                value = element.checked;
                            }
                            commandValue[element.name] = value;
                        }
                    }

                    if (!link.hasAttribute("data-wysihtml5-skip")) {
                        that.execCommand(command, commandValue);
                        event.preventDefault();
                    }
                });

                dom.delegate(container, "select[data-wysihtml5-command]", "change", function (event) {
                    var link = this,
                        command = link.getAttribute("data-wysihtml5-command"),
                        commandValue = link.value;
                    that.execCommand(command, commandValue);
                    event.preventDefault();
                });

                dom.delegate(container, "input[data-wysihtml5-command]", "change", function (event) {
                    var link = this,
                        command = link.getAttribute("data-wysihtml5-command"),
                        commandValue = link.type === "checkbox" ? link.checked : link.value;
                    that.execCommand(command, commandValue);
                    event.preventDefault();
                });

                dom.delegate(container, "[data-wysihtml5-action]", "click", function (event) {
                    var action = this.getAttribute("data-wysihtml5-action");
                    that.execAction(action);
                    event.preventDefault();
                });

                editor.on("focus:composer", function () {
                    that.bookmark = null;
                    clearInterval(that.interval);
                    that.interval = setInterval(function () {
                        that._updateLinkStates();
                    }, 500);
                });

                editor.on("blur:composer", function () {
                    clearInterval(that.interval);
                });

                editor.on("destroy:composer", function () {
                    clearInterval(that.interval);
                });

                editor.on("change_view", function (currentView) {
                    // Set timeout needed in order to let the blur event fire first
                    setTimeout(function () {
                        that.commandsDisabled = (currentView !== "composer");
                        that._updateLinkStates();
                        if (that.commandsDisabled) {
                            dom.addClass(container, CLASS_NAME_COMMANDS_DISABLED);
                        } else {
                            dom.removeClass(container, CLASS_NAME_COMMANDS_DISABLED);
                        }
                    }, 0);
                });
            },

            _updateLinkStates : function () {
                var commandMapping = this.commandMapping,
                    actionMapping = this.actionMapping,
                    i,
                    state,
                    action,
                    command;
                // every millisecond counts... this is executed quite often

                for (i in commandMapping) {
                    command = commandMapping[i];
                    if (!this.commandsDisabled) {
                        var func = wysihtml5.util.getObjectProperty(window, command.func);
                        if (func) {
                            state = this.composer.commands.callbackState(command.name, command.value, command.isDefault);
                            if (wysihtml5.lang.object(state).isArray()) {
                                // Grab first and only object/element in state array, otherwise convert state into boolean
                                // to avoid showing a dialog for multiple selected elements which may have different attributes
                                // eg. when two links with different href are selected, the state will be an array consisting of both link elements
                                // but the dialog interface can only update one
                                state = state.length === 1 ? state[0] : true;
                            }
                            dom.removeClass(command.link, CLASS_NAME_COMMAND_DISABLED);
                            if (command.group) {
                                dom.removeClass(command.group, CLASS_NAME_COMMAND_DISABLED);
                            }
                            func(command.link, state, command.elementName, command.name, command.value, command.isDefault);
                        }
                    }
                }

                for (i in actionMapping) {
                    action = actionMapping[i];
                    if (action.name === "change_view") {
                        action.state = this.editor.currentView === this.editor.textarea;
                        if (action.state) {
                            dom.addClass(action.link, CLASS_NAME_ACTION_ACTIVE);
                        } else {
                            dom.removeClass(action.link, CLASS_NAME_ACTION_ACTIVE);
                        }
                    }
                }
            },

            show : function () {
                this.container.style.display = "";
            },

            hide : function () {
                this.container.style.display = "none";
            }
        });
})(wysihtml5);
/**
 * WYSIHTML5 Editor
 *
 * @param {Element} textareaElement Reference to the textarea which should be turned into a rich text interface
 * @param {Object} [config] See defaultConfig object below for explanation of each individual config option
 *
 * @events
 *    load
 *    beforeload (for internal use only)
 *    focus
 *    focus:composer
 *    click:composer
 *    focus:textarea
 *    blur
 *    blur:composer
 *    blur:textarea
 *    change
 *    change:composer
 *    change:textarea
 *    paste
 *    paste:composer
 *    paste:textarea
 *    newword:composer
 *    destroy:composer
 *    undo:composer
 *    redo:composer
 *    beforecommand:composer
 *    aftercommand:composer
 *    enable:composer
 *    disable:composer
 *    change_view
 */
(function (wysihtml5) {
    var undef;

    var defaultConfig = {
        // Give the editor a name, the name will also be set as class name on the iframe and on the iframe's body
        name : undef,
        // Whether the editor should look like the textarea (by adopting styles)
        style : true,
        // Id of the toolbar element, pass falsey value if you don't want any toolbar logic
        toolbar : undef,
        // Whether urls, entered by the user should automatically become clickable-links
        autoLink : true,
        // Object which includes parser rules to apply when html gets inserted via copy & paste
        // See parser_rules/*.js for examples
        parserRules : {tags : {br : {}, span : {}, div : {}, p : {}}, classes : {}},
        // Parser method to use when the user inserts content via copy & paste
        parser : wysihtml5.dom.parse,
        // Class name which should be set on the contentEditable element in the created sandbox iframe, can be styled via the 'stylesheets' option
        composerClassName : "wysihtml5-editor",
        // Class name to add to the body when the wysihtml5 editor is supported
        bodyClassName : "wysihtml5-supported",
        // By default wysihtml5 will insert a <br> for line breaks, set this to false to use <p>
        useLineBreaks : true,
        pasteAsPlainText : false,
        // Array (or single string) of stylesheet urls to be loaded in the editor's iframe
        stylesheets : [],
        // Placeholder text to use, defaults to the placeholder attribute on the textarea element
        placeholderText : undef,
        // Whether the rich text editor should be rendered on touch devices (wysihtml5 >= 0.3.0 comes with basic support for iOS 5)
        supportTouchDevices : true
    };

    wysihtml5.Editor = wysihtml5.lang.Dispatcher.extend(
        /** @scope wysihtml5.Editor.prototype */ {
            constructor : function (textareaElement, config) {
                this.textareaElement = typeof(textareaElement) === "string" ? document.getElementById(textareaElement) : textareaElement;
                this.config = wysihtml5.lang.object({}).merge(defaultConfig).merge(config).get();
                this.textarea = new wysihtml5.views.Textarea(this, this.textareaElement, this.config);
                this.currentView = this.textarea;
                this._isCompatible = wysihtml5.browser.supported();

                // Sort out unsupported/unwanted browsers here
                if (!this._isCompatible || (!this.config.supportTouchDevices && wysihtml5.browser.isTouchDevice())) {
                    var that = this;
                    setTimeout(function () {
                        that.fire("beforeload").fire("load");
                    }, 0);
                    return;
                }

                // Add class name to body, to indicate that the editor is supported
                wysihtml5.dom.addClass(document.body, this.config.bodyClassName);

                this.composer = new wysihtml5.views.Composer(this, this.textareaElement, this.config);
                this.currentView = this.composer;

                if (typeof(this.config.parser) === "function") {
                    this._initParser();
                }

                if (this.config.parserRules) {
                    this.parserRules = this.config.parserRules;
                }

                this.on("beforeload", function () {
                    this.synchronizer = new wysihtml5.views.Synchronizer(this, this.textarea, this.composer);
                    if (this.config.toolbar) {
                        this.toolbar = new wysihtml5.toolbar.Toolbar(this, this.config.toolbar);
                    }
                });
                this.composer._create();
                try {
                    console.log("Heya! This page is using wysihtml5 for rich text editing. Check out https://github.com/xing/wysihtml5");
                } catch (e) {
                }
            },

            setToolbar : function (toolbar) {
                this.toolbar = new wysihtml5.toolbar.Toolbar(this, toolbar);
            },

            isCompatible : function () {
                return this._isCompatible;
            },

            clear : function () {
                this.currentView.clear();
                return this;
            },

            getValue : function (parse) {
                return this.currentView.getValue(parse);
            },

            setValue : function (html, parse) {
                this.fire("unset_placeholder");

                if (!html) {
                    return this.clear();
                }

                this.currentView.setValue(html, parse);
                return this;
            },

            focus : function (setToEnd) {
                this.currentView.focus(setToEnd);
                return this;
            },

            /**
             * Deactivate editor (make it readonly)
             */
            disable : function () {
                this.currentView.disable();
                return this;
            },

            /**
             * Activate editor
             */
            enable : function () {
                this.currentView.enable();
                return this;
            },

            isEmpty : function () {
                return this.currentView.isEmpty();
            },

            hasPlaceholderSet : function () {
                return this.currentView.hasPlaceholderSet();
            },

            parse : function (htmlOrElement, preProcess) {
                var returnValue = this.config.parser(htmlOrElement, this.config.parserRules, this.composer.sandbox.getDocument(), true, preProcess);
                if (typeof(htmlOrElement) === "object") {
                    wysihtml5.quirks.redraw(htmlOrElement);
                }
                return returnValue;
            },

            /**
             * Prepare html parser logic
             *  - Observes for paste and drop
             */
            _initParser : function () {
                this.on("paste:composer", function () {
                    var keepScrollPosition = true,
                        that = this;
                    that.composer.selection.executeAndRestore(function () {
                        wysihtml5.quirks.cleanPastedHTML(that.composer.element);
                        that.parse(that.composer.element);
                    }, keepScrollPosition);
                });
            }
        });
})(wysihtml5);

/**
 * These rules define which tags and css classes are supported and which tags should be specially treated.
 *
 * Examples based on this rule set:
 *
 *    <a href="http://foobar.com">foo</a>
 *    ... becomes ...
 *    <a href="http://foobar.com" target="_blank" rel="nofollow">foo</a>
 *
 *    <img align="left" src="http://foobar.com/image.png">
 *    ... becomes ...
 *    <img class="wysiwyg-float-left" src="http://foobar.com/image.png" alt="">
 *
 *    <div>foo<script>alert(document.cookie)</script></div>
 *    ... becomes ...
 *    <div>foo</div>
 *
 *    <marquee>foo</marquee>
 *    ... becomes ...
 *    <span>foo</marquee>
 *
 *    foo <br clear="both"> bar
 *    ... becomes ...
 *    foo <br class="wysiwyg-clear-both"> bar
 *
 *    <div>hello <iframe src="http://google.com"></iframe></div>
 *    ... becomes ...
 *    <div>hello </div>
 *
 *    <center>hello</center>
 *    ... becomes ...
 *    <div class="wysiwyg-text-align-center">hello</div>
 */
var wysihtml5SupportedParserRules = {
    /**
     * CSS Class white-list
     * Following css classes won't be removed when parsed by the wysihtml5 html parser
     */
    "classes" : {
        "textEditor-customDataAttr" : 1
    },
    /**
     * Tag list
     *
     * Following options are available:
     *
     *    - add_class:        converts and deletes the given HTML4 attribute (align, clear, ...) via the given method to a css class
     *                        The following methods are implemented in wysihtml5.dom.parse:
     *                          - align_text:  converts align attribute values (right/left/center/justify) to their corresponding css class "wysiwyg-text-align-*")
     <p align="center">foo</p> ... becomes ... <p> class="wysiwyg-text-align-center">foo</p>
     *                          - clear_br:    converts clear attribute values left/right/all/both to their corresponding css class "wysiwyg-clear-*"
     *                            <br clear="all"> ... becomes ... <br class="wysiwyg-clear-both">
     *                          - align_img:    converts align attribute values (right/left) on <img> to their corresponding css class "wysiwyg-float-*"
     *
     *    - remove:             removes the element and it's content
     *
     *    - rename_tag:         renames the element to the given tag
     *
     *    - set_class:          adds the given class to the element (note: make sure that the class is in the "classes" white list above)
     *
     *    - set_attributes:     sets/overrides the given attributes
     *
     *    - remove_attributes:  remove_attributes:  remove given attributes. [attr, property, endString] -> remove attribute property if it ends with endString.
     *
     *    - check_attributes:   checks the given HTML attribute via the given method
     *                            - url:      checks whether the given string is an url, deletes the attribute if not
     *                            - alt:      strips unwanted characters. if the attribute is not set, then it gets set (to ensure valid and compatible HTML)
     *                            - numbers:  ensures that the attribute only contains numeric characters
     */
    "tags" : {
        "ul" : {},
        "ol" : {},
        "li" : {},
        "b" : {},
        "i" : {},
        "u" : {},
        "sup" : {},
        "sub" : {},
        "br" : {
            "remove_attributes" : ["style"]
        },
        "h1" : {},
        "h2" : {},
        "h3" : {},
        "h4" : {},
        "h5" : {},
        "h6" : {},
        "a" : {
            "check_attributes" : {
                "href" : "url"
            },
            "set_attributes" : {
                "rel" : "nofollow",
                "target" : "_blank"
            },
            "remove_attributes" : ["style,background-color"]
        },
        "q" : {
            "check_attributes" : {
                "cite" : "url"
            }
        },
        "hr" : {},
        "pre" : {},
        "span" : {
            "remove_attributes" : ["style,line-height", "style,text-align", "style,margin-left", "style,margin-right", "style,margin-top", "style,margin-bottom", "style,margin"]
        },
        "p" : {},
        "table" : {
            "check_attributes" : {
                "cellpadding" : "any",
                "cellspacing" : "any",
                "border" : "any",
                "width" : "any",
                "height" : "any"
            }
        },
        "thead" : {},
        "tfoot" : {},
        "th" : {},
        "col" : {
            "check_attributes" : {
                "span" : "numbers"
            }
        },
        "tbody" : {},
        "tr" : {},
        "td" : {},
        "form" : {
            "remove" : 1
        },
        "code" : {
            "remove" : 1
        },
        "title" : {
            "remove" : 1
        },
        "area" : {
            "remove" : 1
        },
        "command" : {
            "remove" : 1
        },
        "iframe" : {
            "remove" : 1
        },
        "img" : {
            "remove" : 1
        },
        "noframes" : {
            "remove" : 1
        },
        "bgsound" : {
            "remove" : 1
        },
        "basefont" : {
            "remove" : 1
        },
        "base" : {
            "remove" : 1
        },
        "video" : {
            "remove" : 1
        },
        "canvas" : {
            "remove" : 1
        },
        "applet" : {
            "remove" : 1
        },
        "spacer" : {
            "remove" : 1
        },
        "source" : {
            "remove" : 1
        },
        "frame" : {
            "remove" : 1
        },
        "style" : {
            "remove" : 1
        },
        "device" : {
            "remove" : 1
        },
        "embed" : {
            "remove" : 1
        },
        "noembed" : {
            "remove" : 1
        },
        "xml" : {
            "remove" : 1
        },
        "param" : {
            "remove" : 1
        },
        "audio" : {
            "remove" : 1
        },
        "nextid" : {
            "remove" : 1
        },
        "link" : {
            "remove" : 1
        },
        "script" : {
            "remove" : 1
        },
        "colgroup" : {},
        "o:p" : {
            "remove" : 1
        },
        "comment" : {
            "remove" : 1
        },
        "frameset" : {
            "remove" : 1
        },
        "head" : {
            "remove" : 1
        },
        "object" : {
            "remove" : 1
        },
        "track" : {
            "remove" : 1
        },
        "wbr" : {
            "remove" : 1
        },
        "button" : {
            "remove" : 1
        },
        "noscript" : {
            "remove" : 1
        },
        "svg" : {
            "remove" : 1
        },
        "input" : {
            "remove" : 1
        },
        "keygen" : {
            "remove" : 1
        },
        "meta" : {
            "remove" : 1
        },
        "isindex" : {
            "remove" : 1
        },
        "del" : {
            "remove" : 1
        },
        "map" : {
            "remove" : 1
        },
        "address" : {
            "rename_tag" : "p"
        },
        "nav" : {
            "rename_tag" : "p"
        },
        "multicol" : {
            "rename_tag" : "p"
        },
        "figure" : {
            "rename_tag" : "p"
        },
        "figcaption" : {
            "rename_tag" : "p"
        },
        "footer" : {
            "rename_tag" : "p"
        },
        "fieldset" : {
            "rename_tag" : "p"
        },
        "div" : {
            "rename_tag" : "span"
        },
        "aside" : {
            "rename_tag" : "p"
        },
        "section" : {
            "rename_tag" : "p"
        },
        "body" : {
            "rename_tag" : "p"
        },
        "html" : {
            "rename_tag" : "p"
        },
        "hgroup" : {
            "rename_tag" : "p"
        },
        "center" : {
            "rename_tag" : "p"
        },
        "article" : {
            "rename_tag" : "p"
        },
        "header" : {
            "rename_tag" : "p"
        },
        "dl" : {
            "rename_tag" : "p"
        },
        "dd" : {
            "rename_tag" : "span"
        },
        "dt" : {
            "rename_tag" : "span"
        },
        "xmp" : {
            "rename_tag" : "span"
        },
        "small" : {
            "rename_tag" : "span"
        },
        "time" : {
            "rename_tag" : "span"
        },
        "ruby" : {
            "rename_tag" : "span"
        },
        "rt" : {
            "rename_tag" : "span"
        },
        "rp" : {
            "rename_tag" : "span"
        },
        "rb" : {
            "rename_tag" : "span"
        },
        "acronym" : {
            "rename_tag" : "span"
        },
        "details" : {
            "rename_tag" : "span"
        },
        "summary" : {
            "rename_tag" : "span"
        },
        "bdi" : {
            "rename_tag" : "span"
        },
        "progress" : {
            "rename_tag" : "span"
        },
        "dfn" : {
            "rename_tag" : "span"
        },
        "abbr" : {
            "rename_tag" : "span"
        },
        "s" : {
            "rename_tag" : "span"
        },
        "strike" : {
            "rename_tag" : "span"
        },
        "option" : {
            "rename_tag" : "span"
        },
        "optgroup" : {
            "rename_tag" : "span"
        },
        "select" : {
            "rename_tag" : "span"
        },
        "big" : {
            "rename_tag" : "span"
        },
        "mark" : {
            "rename_tag" : "span"
        },
        "caption" : {
            "rename_tag" : "span"
        },
        "output" : {
            "rename_tag" : "span"
        },
        "marquee" : {
            "rename_tag" : "span"
        },
        "nobr" : {
            "rename_tag" : "span"
        },
        "var" : {
            "rename_tag" : "span"
        },
        "meter" : {
            "rename_tag" : "span"
        },
        "blockquote" : {
            "rename_tag" : "span"
        },
        "textarea" : {
            "rename_tag" : "span"
        },
        "font" : {
            "rename_tag" : "span"
        },
        "tt" : {
            "rename_tag" : "span"
        },
        "blink" : {
            "rename_tag" : "span"
        },
        "plaintext" : {
            "rename_tag" : "span"
        },
        "legend" : {
            "rename_tag" : "span"
        },
        "label" : {
            "rename_tag" : "span"
        },
        "kbd" : {
            "rename_tag" : "span"
        },
        "datalist" : {
            "rename_tag" : "span"
        },
        "samp" : {
            "rename_tag" : "span"
        },
        "bdo" : {
            "rename_tag" : "span"
        },
        "ins" : {
            "rename_tag" : "span"
        },
        "strong" : {
            "rename_tag" : "b"
        },
        "em" : {
            "rename_tag" : "i"
        },
        "cite" : {
            "rename_tag" : "i"
        },
        "dir" : {
            "rename_tag" : "ul"
        },
        "menu" : {
            "rename_tag" : "ul"
        },
        "menuitem" : {
            "rename_tag" : "li"
        }
    },
    /**
     * CSS styles white-list
     * Following css styles won't be removed when parsed by the wysihtml5 html parser
     */
    "styles" : [
                "font-family",
                "font-size",
                "color",
                "background-color",
                "letter-spacing",
                "line-height",
                "text-align",
                "margin-left",
                "margin-right",
                "margin-top",
                "margin-bottom",
                "list-style-type",
                "white-space",
                "border-collapse"
                ]
};

/*!

 handlebars v4.0.5

 Copyright (C) 2011-2015 by Yehuda Katz

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.

 @license
 */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["Handlebars"] = factory();
	else
		root["Handlebars"] = factory();
})(this, function() {
	return /******/ (function(modules) { // webpackBootstrap
		/******/ 	// The module cache
		/******/ 	var installedModules = {};

		/******/ 	// The require function
		/******/ 	function __webpack_require__(moduleId) {

			/******/ 		// Check if module is in cache
			/******/ 		if(installedModules[moduleId])
			/******/ 			return installedModules[moduleId].exports;

			/******/ 		// Create a new module (and put it into the cache)
			/******/ 		var module = installedModules[moduleId] = {
				/******/ 			exports: {},
				/******/ 			id: moduleId,
				/******/ 			loaded: false
				/******/ 		};

			/******/ 		// Execute the module function
			/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

			/******/ 		// Flag the module as loaded
			/******/ 		module.loaded = true;

			/******/ 		// Return the exports of the module
			/******/ 		return module.exports;
			/******/ 	}


		/******/ 	// expose the modules object (__webpack_modules__)
		/******/ 	__webpack_require__.m = modules;

		/******/ 	// expose the module cache
		/******/ 	__webpack_require__.c = installedModules;

		/******/ 	// __webpack_public_path__
		/******/ 	__webpack_require__.p = "";

		/******/ 	// Load entry module and return exports
		/******/ 	return __webpack_require__(0);
		/******/ })
		/************************************************************************/
		/******/ ([
		/* 0 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireWildcard = __webpack_require__(1)['default'];

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;

			var _handlebarsBase = __webpack_require__(3);

			var base = _interopRequireWildcard(_handlebarsBase);

			// Each of these augment the Handlebars object. No need to setup here.
			// (This is done to easily share code between commonjs and browse envs)

			var _handlebarsSafeString = __webpack_require__(17);

			var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString);

			var _handlebarsException = __webpack_require__(5);

			var _handlebarsException2 = _interopRequireDefault(_handlebarsException);

			var _handlebarsUtils = __webpack_require__(4);

			var Utils = _interopRequireWildcard(_handlebarsUtils);

			var _handlebarsRuntime = __webpack_require__(18);

			var runtime = _interopRequireWildcard(_handlebarsRuntime);

			var _handlebarsNoConflict = __webpack_require__(19);

			var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict);

			// For compatibility and usage outside of module systems, make the Handlebars object a namespace
			function create() {
				var hb = new base.HandlebarsEnvironment();

				Utils.extend(hb, base);
				hb.SafeString = _handlebarsSafeString2['default'];
				hb.Exception = _handlebarsException2['default'];
				hb.Utils = Utils;
				hb.escapeExpression = Utils.escapeExpression;

				hb.VM = runtime;
				hb.template = function (spec) {
					return runtime.template(spec, hb);
				};

				return hb;
			}

			var inst = create();
			inst.create = create;

			_handlebarsNoConflict2['default'](inst);

			inst['default'] = inst;

			exports['default'] = inst;
			module.exports = exports['default'];

			/***/ },
		/* 1 */
		/***/ function(module, exports) {

			"use strict";

			exports["default"] = function (obj) {
				if (obj && obj.__esModule) {
					return obj;
				} else {
					var newObj = {};

					if (obj != null) {
						for (var key in obj) {
							if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
						}
					}

					newObj["default"] = obj;
					return newObj;
				}
			};

			exports.__esModule = true;

			/***/ },
		/* 2 */
		/***/ function(module, exports) {

			"use strict";

			exports["default"] = function (obj) {
				return obj && obj.__esModule ? obj : {
					"default": obj
				};
			};

			exports.__esModule = true;

			/***/ },
		/* 3 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;
			exports.HandlebarsEnvironment = HandlebarsEnvironment;

			var _utils = __webpack_require__(4);

			var _exception = __webpack_require__(5);

			var _exception2 = _interopRequireDefault(_exception);

			var _helpers = __webpack_require__(6);

			var _decorators = __webpack_require__(14);

			var _logger = __webpack_require__(16);

			var _logger2 = _interopRequireDefault(_logger);

			var VERSION = '4.0.5';
			exports.VERSION = VERSION;
			var COMPILER_REVISION = 7;

			exports.COMPILER_REVISION = COMPILER_REVISION;
			var REVISION_CHANGES = {
				1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
				2: '== 1.0.0-rc.3',
				3: '== 1.0.0-rc.4',
				4: '== 1.x.x',
				5: '== 2.0.0-alpha.x',
				6: '>= 2.0.0-beta.1',
				7: '>= 4.0.0'
			};

			exports.REVISION_CHANGES = REVISION_CHANGES;
			var objectType = '[object Object]';

			function HandlebarsEnvironment(helpers, partials, decorators) {
				this.helpers = helpers || {};
				this.partials = partials || {};
				this.decorators = decorators || {};

				_helpers.registerDefaultHelpers(this);
				_decorators.registerDefaultDecorators(this);
			}

			HandlebarsEnvironment.prototype = {
				constructor: HandlebarsEnvironment,

				logger: _logger2['default'],
				log: _logger2['default'].log,

				registerHelper: function registerHelper(name, fn) {
					if (_utils.toString.call(name) === objectType) {
						if (fn) {
							throw new _exception2['default']('Arg not supported with multiple helpers');
						}
						_utils.extend(this.helpers, name);
					} else {
						this.helpers[name] = fn;
					}
				},
				unregisterHelper: function unregisterHelper(name) {
					delete this.helpers[name];
				},

				registerPartial: function registerPartial(name, partial) {
					if (_utils.toString.call(name) === objectType) {
						_utils.extend(this.partials, name);
					} else {
						if (typeof partial === 'undefined') {
							throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined');
						}
						this.partials[name] = partial;
					}
				},
				unregisterPartial: function unregisterPartial(name) {
					delete this.partials[name];
				},

				registerDecorator: function registerDecorator(name, fn) {
					if (_utils.toString.call(name) === objectType) {
						if (fn) {
							throw new _exception2['default']('Arg not supported with multiple decorators');
						}
						_utils.extend(this.decorators, name);
					} else {
						this.decorators[name] = fn;
					}
				},
				unregisterDecorator: function unregisterDecorator(name) {
					delete this.decorators[name];
				}
			};

			var log = _logger2['default'].log;

			exports.log = log;
			exports.createFrame = _utils.createFrame;
			exports.logger = _logger2['default'];

			/***/ },
		/* 4 */
		/***/ function(module, exports) {

			'use strict';

			exports.__esModule = true;
			exports.extend = extend;
			exports.indexOf = indexOf;
			exports.escapeExpression = escapeExpression;
			exports.isEmpty = isEmpty;
			exports.createFrame = createFrame;
			exports.blockParams = blockParams;
			exports.appendContextPath = appendContextPath;
			var escape = {
				'&': '&amp;',
				'<': '&lt;',
				'>': '&gt;',
				'"': '&quot;',
				"'": '&#x27;',
				'`': '&#x60;',
				'=': '&#x3D;'
			};

			var badChars = /[&<>"'`=]/g,
				possible = /[&<>"'`=]/;

			function escapeChar(chr) {
				return escape[chr];
			}

			function extend(obj /* , ...source */) {
				for (var i = 1; i < arguments.length; i++) {
					for (var key in arguments[i]) {
						if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
							obj[key] = arguments[i][key];
						}
					}
				}

				return obj;
			}

			var toString = Object.prototype.toString;

			exports.toString = toString;
			// Sourced from lodash
			// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
			/* eslint-disable func-style */
			var isFunction = function isFunction(value) {
				return typeof value === 'function';
			};
			// fallback for older versions of Chrome and Safari
			/* istanbul ignore next */
			if (isFunction(/x/)) {
				exports.isFunction = isFunction = function (value) {
					return typeof value === 'function' && toString.call(value) === '[object Function]';
				};
			}
			exports.isFunction = isFunction;

			/* eslint-enable func-style */

			/* istanbul ignore next */
			var isArray = Array.isArray || function (value) {
				return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
			};

			exports.isArray = isArray;
			// Older IE versions do not directly support indexOf so we must implement our own, sadly.

			function indexOf(array, value) {
				for (var i = 0, len = array.length; i < len; i++) {
					if (array[i] === value) {
						return i;
					}
				}
				return -1;
			}

			function escapeExpression(string) {
				if (typeof string !== 'string') {
					// don't escape SafeStrings, since they're already safe
					if (string && string.toHTML) {
						return string.toHTML();
					} else if (string == null) {
						return '';
					} else if (!string) {
						return string + '';
					}

					// Force a string conversion as this will be done by the append regardless and
					// the regex test will do this transparently behind the scenes, causing issues if
					// an object's to string has escaped characters in it.
					string = '' + string;
				}

				if (!possible.test(string)) {
					return string;
				}
				return string.replace(badChars, escapeChar);
			}

			function isEmpty(value) {
				if (!value && value !== 0) {
					return true;
				} else if (isArray(value) && value.length === 0) {
					return true;
				} else {
					return false;
				}
			}

			function createFrame(object) {
				var frame = extend({}, object);
				frame._parent = object;
				return frame;
			}

			function blockParams(params, ids) {
				params.path = ids;
				return params;
			}

			function appendContextPath(contextPath, id) {
				return (contextPath ? contextPath + '.' : '') + id;
			}

			/***/ },
		/* 5 */
		/***/ function(module, exports) {

			'use strict';

			exports.__esModule = true;

			var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];

			function Exception(message, node) {
				var loc = node && node.loc,
					line = undefined,
					column = undefined;
				if (loc) {
					line = loc.start.line;
					column = loc.start.column;

					message += ' - ' + line + ':' + column;
				}

				var tmp = Error.prototype.constructor.call(this, message);

				// Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
				for (var idx = 0; idx < errorProps.length; idx++) {
					this[errorProps[idx]] = tmp[errorProps[idx]];
				}

				/* istanbul ignore else */
				if (Error.captureStackTrace) {
					Error.captureStackTrace(this, Exception);
				}

				if (loc) {
					this.lineNumber = line;
					this.column = column;
				}
			}

			Exception.prototype = new Error();

			exports['default'] = Exception;
			module.exports = exports['default'];

			/***/ },
		/* 6 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;
			exports.registerDefaultHelpers = registerDefaultHelpers;

			var _helpersBlockHelperMissing = __webpack_require__(7);

			var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing);

			var _helpersEach = __webpack_require__(8);

			var _helpersEach2 = _interopRequireDefault(_helpersEach);

			var _helpersHelperMissing = __webpack_require__(9);

			var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing);

			var _helpersIf = __webpack_require__(10);

			var _helpersIf2 = _interopRequireDefault(_helpersIf);

			var _helpersLog = __webpack_require__(11);

			var _helpersLog2 = _interopRequireDefault(_helpersLog);

			var _helpersLookup = __webpack_require__(12);

			var _helpersLookup2 = _interopRequireDefault(_helpersLookup);

			var _helpersWith = __webpack_require__(13);

			var _helpersWith2 = _interopRequireDefault(_helpersWith);

			function registerDefaultHelpers(instance) {
				_helpersBlockHelperMissing2['default'](instance);
				_helpersEach2['default'](instance);
				_helpersHelperMissing2['default'](instance);
				_helpersIf2['default'](instance);
				_helpersLog2['default'](instance);
				_helpersLookup2['default'](instance);
				_helpersWith2['default'](instance);
			}

			/***/ },
		/* 7 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			exports['default'] = function (instance) {
				instance.registerHelper('blockHelperMissing', function (context, options) {
					var inverse = options.inverse,
						fn = options.fn;

					if (context === true) {
						return fn(this);
					} else if (context === false || context == null) {
						return inverse(this);
					} else if (_utils.isArray(context)) {
						if (context.length > 0) {
							if (options.ids) {
								options.ids = [options.name];
							}

							return instance.helpers.each(context, options);
						} else {
							return inverse(this);
						}
					} else {
						if (options.data && options.ids) {
							var data = _utils.createFrame(options.data);
							data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
							options = { data: data };
						}

						return fn(context, options);
					}
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 8 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			var _exception = __webpack_require__(5);

			var _exception2 = _interopRequireDefault(_exception);

			exports['default'] = function (instance) {
				instance.registerHelper('each', function (context, options) {
					if (!options) {
						throw new _exception2['default']('Must pass iterator to #each');
					}

					var fn = options.fn,
						inverse = options.inverse,
						i = 0,
						ret = '',
						data = undefined,
						contextPath = undefined;

					if (options.data && options.ids) {
						contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
					}

					if (_utils.isFunction(context)) {
						context = context.call(this);
					}

					if (options.data) {
						data = _utils.createFrame(options.data);
					}

					function execIteration(field, index, last) {
						if (data) {
							data.key = field;
							data.index = index;
							data.first = index === 0;
							data.last = !!last;

							if (contextPath) {
								data.contextPath = contextPath + field;
							}
						}

						ret = ret + fn(context[field], {
							data: data,
							blockParams: _utils.blockParams([context[field], field], [contextPath + field, null])
						});
					}

					if (context && typeof context === 'object') {
						if (_utils.isArray(context)) {
							for (var j = context.length; i < j; i++) {
								if (i in context) {
									execIteration(i, i, i === context.length - 1);
								}
							}
						} else {
							var priorKey = undefined;

							for (var key in context) {
								if (context.hasOwnProperty(key)) {
									// We're running the iterations one step out of sync so we can detect
									// the last iteration without have to scan the object twice and create
									// an itermediate keys array.
									if (priorKey !== undefined) {
										execIteration(priorKey, i - 1);
									}
									priorKey = key;
									i++;
								}
							}
							if (priorKey !== undefined) {
								execIteration(priorKey, i - 1, true);
							}
						}
					}

					if (i === 0) {
						ret = inverse(this);
					}

					return ret;
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 9 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;

			var _exception = __webpack_require__(5);

			var _exception2 = _interopRequireDefault(_exception);

			exports['default'] = function (instance) {
				instance.registerHelper('helperMissing', function () /* [args, ]options */{
					if (arguments.length === 1) {
						// A missing field in a {{foo}} construct.
						return undefined;
					} else {
						// Someone is actually trying to call something, blow up.
						throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
					}
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 10 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			exports['default'] = function (instance) {
				instance.registerHelper('if', function (conditional, options) {
					if (_utils.isFunction(conditional)) {
						conditional = conditional.call(this);
					}

					// Default behavior is to render the positive path if the value is truthy and not empty.
					// The `includeZero` option may be set to treat the condtional as purely not empty based on the
					// behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
					if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) {
						return options.inverse(this);
					} else {
						return options.fn(this);
					}
				});

				instance.registerHelper('unless', function (conditional, options) {
					return instance.helpers['if'].call(this, conditional, { fn: options.inverse, inverse: options.fn, hash: options.hash });
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 11 */
		/***/ function(module, exports) {

			'use strict';

			exports.__esModule = true;

			exports['default'] = function (instance) {
				instance.registerHelper('log', function () /* message, options */{
					var args = [undefined],
						options = arguments[arguments.length - 1];
					for (var i = 0; i < arguments.length - 1; i++) {
						args.push(arguments[i]);
					}

					var level = 1;
					if (options.hash.level != null) {
						level = options.hash.level;
					} else if (options.data && options.data.level != null) {
						level = options.data.level;
					}
					args[0] = level;

					instance.log.apply(instance, args);
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 12 */
		/***/ function(module, exports) {

			'use strict';

			exports.__esModule = true;

			exports['default'] = function (instance) {
				instance.registerHelper('lookup', function (obj, field) {
					return obj && obj[field];
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 13 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			exports['default'] = function (instance) {
				instance.registerHelper('with', function (context, options) {
					if (_utils.isFunction(context)) {
						context = context.call(this);
					}

					var fn = options.fn;

					if (!_utils.isEmpty(context)) {
						var data = options.data;
						if (options.data && options.ids) {
							data = _utils.createFrame(options.data);
							data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);
						}

						return fn(context, {
							data: data,
							blockParams: _utils.blockParams([context], [data && data.contextPath])
						});
					} else {
						return options.inverse(this);
					}
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 14 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;
			exports.registerDefaultDecorators = registerDefaultDecorators;

			var _decoratorsInline = __webpack_require__(15);

			var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline);

			function registerDefaultDecorators(instance) {
				_decoratorsInline2['default'](instance);
			}

			/***/ },
		/* 15 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			exports['default'] = function (instance) {
				instance.registerDecorator('inline', function (fn, props, container, options) {
					var ret = fn;
					if (!props.partials) {
						props.partials = {};
						ret = function (context, options) {
							// Create a new partials stack frame prior to exec.
							var original = container.partials;
							container.partials = _utils.extend({}, original, props.partials);
							var ret = fn(context, options);
							container.partials = original;
							return ret;
						};
					}

					props.partials[options.args[0]] = options.fn;

					return ret;
				});
			};

			module.exports = exports['default'];

			/***/ },
		/* 16 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			exports.__esModule = true;

			var _utils = __webpack_require__(4);

			var logger = {
				methodMap: ['debug', 'info', 'warn', 'error'],
				level: 'info',

				// Maps a given level value to the `methodMap` indexes above.
				lookupLevel: function lookupLevel(level) {
					if (typeof level === 'string') {
						var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase());
						if (levelMap >= 0) {
							level = levelMap;
						} else {
							level = parseInt(level, 10);
						}
					}

					return level;
				},

				// Can be overridden in the host environment
				log: function log(level) {
					level = logger.lookupLevel(level);

					if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) {
						var method = logger.methodMap[level];
						if (!console[method]) {
							// eslint-disable-line no-console
							method = 'log';
						}

						for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
							message[_key - 1] = arguments[_key];
						}

						console[method].apply(console, message); // eslint-disable-line no-console
					}
				}
			};

			exports['default'] = logger;
			module.exports = exports['default'];

			/***/ },
		/* 17 */
		/***/ function(module, exports) {

			// Build out our basic SafeString type
			'use strict';

			exports.__esModule = true;
			function SafeString(string) {
				this.string = string;
			}

			SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
				return '' + this.string;
			};

			exports['default'] = SafeString;
			module.exports = exports['default'];

			/***/ },
		/* 18 */
		/***/ function(module, exports, __webpack_require__) {

			'use strict';

			var _interopRequireWildcard = __webpack_require__(1)['default'];

			var _interopRequireDefault = __webpack_require__(2)['default'];

			exports.__esModule = true;
			exports.checkRevision = checkRevision;
			exports.template = template;
			exports.wrapProgram = wrapProgram;
			exports.resolvePartial = resolvePartial;
			exports.invokePartial = invokePartial;
			exports.noop = noop;

			var _utils = __webpack_require__(4);

			var Utils = _interopRequireWildcard(_utils);

			var _exception = __webpack_require__(5);

			var _exception2 = _interopRequireDefault(_exception);

			var _base = __webpack_require__(3);

			function checkRevision(compilerInfo) {
				var compilerRevision = compilerInfo && compilerInfo[0] || 1,
					currentRevision = _base.COMPILER_REVISION;

				if (compilerRevision !== currentRevision) {
					if (compilerRevision < currentRevision) {
						var runtimeVersions = _base.REVISION_CHANGES[currentRevision],
							compilerVersions = _base.REVISION_CHANGES[compilerRevision];
						throw new _exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');
					} else {
						// Use the embedded version info since the runtime doesn't know about this revision yet
						throw new _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').');
					}
				}
			}

			function template(templateSpec, env) {
				/* istanbul ignore next */
				if (!env) {
					throw new _exception2['default']('No environment passed to template');
				}
				if (!templateSpec || !templateSpec.main) {
					throw new _exception2['default']('Unknown template object: ' + typeof templateSpec);
				}

				templateSpec.main.decorator = templateSpec.main_d;

				// Note: Using env.VM references rather than local var references throughout this section to allow
				// for external users to override these as psuedo-supported APIs.
				env.VM.checkRevision(templateSpec.compiler);

				function invokePartialWrapper(partial, context, options) {
					if (options.hash) {
						context = Utils.extend({}, context, options.hash);
						if (options.ids) {
							options.ids[0] = true;
						}
					}

					partial = env.VM.resolvePartial.call(this, partial, context, options);
					var result = env.VM.invokePartial.call(this, partial, context, options);

					if (result == null && env.compile) {
						options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
						result = options.partials[options.name](context, options);
					}
					if (result != null) {
						if (options.indent) {
							var lines = result.split('\n');
							for (var i = 0, l = lines.length; i < l; i++) {
								if (!lines[i] && i + 1 === l) {
									break;
								}

								lines[i] = options.indent + lines[i];
							}
							result = lines.join('\n');
						}
						return result;
					} else {
						throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
					}
				}

				// Just add water
				var container = {
					strict: function strict(obj, name) {
						if (!(name in obj)) {
							throw new _exception2['default']('"' + name + '" not defined in ' + obj);
						}
						return obj[name];
					},
					lookup: function lookup(depths, name) {
						var len = depths.length;
						for (var i = 0; i < len; i++) {
							if (depths[i] && depths[i][name] != null) {
								return depths[i][name];
							}
						}
					},
					lambda: function lambda(current, context) {
						return typeof current === 'function' ? current.call(context) : current;
					},

					escapeExpression: Utils.escapeExpression,
					invokePartial: invokePartialWrapper,

					fn: function fn(i) {
						var ret = templateSpec[i];
						ret.decorator = templateSpec[i + '_d'];
						return ret;
					},

					programs: [],
					program: function program(i, data, declaredBlockParams, blockParams, depths) {
						var programWrapper = this.programs[i],
							fn = this.fn(i);
						if (data || depths || blockParams || declaredBlockParams) {
							programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
						} else if (!programWrapper) {
							programWrapper = this.programs[i] = wrapProgram(this, i, fn);
						}
						return programWrapper;
					},

					data: function data(value, depth) {
						while (value && depth--) {
							value = value._parent;
						}
						return value;
					},
					merge: function merge(param, common) {
						var obj = param || common;

						if (param && common && param !== common) {
							obj = Utils.extend({}, common, param);
						}

						return obj;
					},

					noop: env.VM.noop,
					compilerInfo: templateSpec.compiler
				};

				function ret(context) {
					var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

					var data = options.data;

					ret._setup(options);
					if (!options.partial && templateSpec.useData) {
						data = initData(context, data);
					}
					var depths = undefined,
						blockParams = templateSpec.useBlockParams ? [] : undefined;
					if (templateSpec.useDepths) {
						if (options.depths) {
							depths = context !== options.depths[0] ? [context].concat(options.depths) : options.depths;
						} else {
							depths = [context];
						}
					}

					function main(context /*, options*/) {
						return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);
					}
					main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);
					return main(context, options);
				}
				ret.isTop = true;

				ret._setup = function (options) {
					if (!options.partial) {
						container.helpers = container.merge(options.helpers, env.helpers);

						if (templateSpec.usePartial) {
							container.partials = container.merge(options.partials, env.partials);
						}
						if (templateSpec.usePartial || templateSpec.useDecorators) {
							container.decorators = container.merge(options.decorators, env.decorators);
						}
					} else {
						container.helpers = options.helpers;
						container.partials = options.partials;
						container.decorators = options.decorators;
					}
				};

				ret._child = function (i, data, blockParams, depths) {
					if (templateSpec.useBlockParams && !blockParams) {
						throw new _exception2['default']('must pass block params');
					}
					if (templateSpec.useDepths && !depths) {
						throw new _exception2['default']('must pass parent depths');
					}

					return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
				};
				return ret;
			}

			function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
				function prog(context) {
					var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

					var currentDepths = depths;
					if (depths && context !== depths[0]) {
						currentDepths = [context].concat(depths);
					}

					return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
				}

				prog = executeDecorators(fn, prog, container, depths, data, blockParams);

				prog.program = i;
				prog.depth = depths ? depths.length : 0;
				prog.blockParams = declaredBlockParams || 0;
				return prog;
			}

			function resolvePartial(partial, context, options) {
				if (!partial) {
					if (options.name === '@partial-block') {
						partial = options.data['partial-block'];
					} else {
						partial = options.partials[options.name];
					}
				} else if (!partial.call && !options.name) {
					// This is a dynamic partial that returned a string
					options.name = partial;
					partial = options.partials[partial];
				}
				return partial;
			}

			function invokePartial(partial, context, options) {
				options.partial = true;
				if (options.ids) {
					options.data.contextPath = options.ids[0] || options.data.contextPath;
				}

				var partialBlock = undefined;
				if (options.fn && options.fn !== noop) {
					options.data = _base.createFrame(options.data);
					partialBlock = options.data['partial-block'] = options.fn;

					if (partialBlock.partials) {
						options.partials = Utils.extend({}, options.partials, partialBlock.partials);
					}
				}

				if (partial === undefined && partialBlock) {
					partial = partialBlock;
				}

				if (partial === undefined) {
					throw new _exception2['default']('The partial ' + options.name + ' could not be found');
				} else if (partial instanceof Function) {
					return partial(context, options);
				}
			}

			function noop() {
				return '';
			}

			function initData(context, data) {
				if (!data || !('root' in data)) {
					data = data ? _base.createFrame(data) : {};
					data.root = context;
				}
				return data;
			}

			function executeDecorators(fn, prog, container, depths, data, blockParams) {
				if (fn.decorator) {
					var props = {};
					prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
					Utils.extend(prog, props);
				}
				return prog;
			}

			/***/ },
		/* 19 */
		/***/ function(module, exports) {

			/* WEBPACK VAR INJECTION */(function(global) {/* global window */
				'use strict';

				exports.__esModule = true;

				exports['default'] = function (Handlebars) {
					/* istanbul ignore next */
					var root = typeof global !== 'undefined' ? global : window,
						$Handlebars = root.Handlebars;
					/* istanbul ignore next */
					Handlebars.noConflict = function () {
						if (root.Handlebars === Handlebars) {
							root.Handlebars = $Handlebars;
						}
						return Handlebars;
					};
				};

				module.exports = exports['default'];
				/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

			/***/ }
		/******/ ])
});
;
/**
 *    xbe4x is javascript implementation of the original ECMAScript for XML (E4X)
 *    Specification (ECMA-357) December 2005. This implementation is designed to emulate
 *    the implementation that is used in SpiderMonkey (Mozilla's JavaScript(TM) Engine)
 *    and therefore Firefox, Thunderbird, and most other Gecko based applications.
 *    Because the Mozilla implementation leaves out certain features of the
 *    specification, so does xbe4x. Please read the README file for a further
 *    explanation of these issues.
 *
 *
 *    @author Sam Shull <http://samshull.blogspot.com/>
 *    @version 0.1
 *
 *    @copyright Copyright (c) 2009 Sam Shull <http://samshull.blogspot.com/>
 *    @license <http://www.opensource.org/licenses/mit-license.html>
 *
 *    Permission is hereby granted, free of charge, to any person obtaining a copy
 *    of this software and associated documentation files (the "Software"), to deal
 *    in the Software without restriction, including without limitation the rights
 *    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *    copies of the Software, and to permit persons to whom the Software is
 *    furnished to do so, subject to the following conditions:
 *
 *    The above copyright notice and this permission notice shall be included in
 *    all copies or substantial portions of the Software.
 *
 *    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *    THE SOFTWARE.
 *
 *
 *    CHANGES:
 */

//this doesn't load if window.XML is already defined
if (!this.XML)
{
    (function ()
    {
        /*
         *
         *
         */
        var undefined, p,
            window                       = this,
            dns                          = [],
            defaultNamespace             = "",
            ELEMENT_NODE                 = 1,
            ATTRIBUTE_NODE               = 2,
            TEXT_NODE                    = 3,
            CDATA_SECTION_NODE           = 4,
            ENTITY_REFERENCE_NODE        = 5,
            ENTITY_NODE                  = 6,
            PROCESSING_INSTRUCTION_NODE  = 7,
            COMMENT_NODE                 = 8,
            DOCUMENT_NODE                = 9,
            DOCUMENT_TYPE_NODE           = 10,
            DOCUMENT_FRAGMENT_NODE       = 11,
            NOTATION_NODE                = 12,
            isNSDef                      = /^xmlns:([\w\-]+)/i,
            toString                     = ({}).toString,
            propertyIsEnumerable         = ({}).propertyIsEnumerable,
            hasOwnProperty               = ({}).hasOwnProperty,
            defaultXMLProperties         = ",prototype,ignoreComments,ignoreProcessingInstructions,ignoreWhitespace," +
                "prettyPrinting,prettyIndent,settings,defaultSettings,setSettings,settings," +
                "propertyIsEnumerable,hasOwnProperty,_setDefaultNamespace,",
            defaultXMLPrototype          = ",_Class,_Name,_Parent,_Value,_InScopeNamespaces,_Attributes,_Children,_Node",
            defaultXMLListPrototype      = ",_Class,_Value,_Children,_TargetObject,_TargetProperty",
            xmlDoc                       = parse("<x/>"),
            piName                       = /^[\w\-]+\s*/,
            XSLT_NS                      = "http://www.w3.org/1999/XSL/Transform";

        /**
         *
         *
         *    @param String | XML $string
         *    @returns XML
         *    @throws SyntaxError
         */
        function XML ($string)
        {
            if (!(this instanceof XML))
            {
                return ToXML($string);
            }

            var x, i, l;

            this._Class = "text";

            this._Name = null;

            this._Value = null;

            this._Parent = null;

            this._InScopeNamespaces = {};

            this._DefaultNamespace = null;

            this._Attributes = {};

            this._Children = [];

            this[0] = this;

            /**
             *
             *
             *
             */
            switch (typeof($string))
            {
                case "undefined":
                case "null":
                    break;
                case "number":
                case "boolean":    $string = ToString($string);
                case "string":

                    x = ToXML(trim($string));
                    if (x)
                    {
                        if (x.length() ===1)
                        {
                            this._Class = x._Class;
                            this._Name = x._Name;
                            this._Value = x._Value;
                            this._InScopeNamespaces = x._InScopeNamespaces;
                            this._DefaultNamespace = x._DefaultNamespace;
                            this._Attributes = x._Attributes;

                            for (i = 0, l = x._Children.length; i < l; ++i)
                            {
                                this._Children[i] = x._Children[i];
                                this._Children[i]._Parent = this;
                            }

                            break;
                        }
                    }

                    throw new SyntaxError();
                    break;
                default:
                    if ($string instanceof XML)
                    {
                        if ($string.length() ===1)
                        {
                            x = $string;
                            this._Class = x._Class;
                            this._Name = x._Name;
                            this._Value = x._Value;
                            this._InScopeNamespaces = x._InScopeNamespaces;
                            this._DefaultNamespace = x._DefaultNamespace;
                            this._Attributes = x._Attributes;

                            for (i = 0, l = x._Children.length; i < l; ++i)
                            {
                                this._Children[i] = x._Children[i];
                                this._Children[i]._Parent = this;
                            }
                        }
                    }
                    break;
            }
        }

        /**
         *    Ignore XML comments. (Default: true.)
         *
         *    @static
         *    @param Namespace ns
         *    @returns void
         */
        XML.setDefaultNamespace = function (ns)
        {
            dns.unshift(defaultNamespace || "");
            defaultNamespace = Namespace(ns);
            return null;
        };

        /**
         *  Use this function to restore the default namespace
         *  to the previous namespace
         *
         */
        XML.restoreDefaultNamespace = function ()
        {
            defaultNamespace = dns.shift() || "";
            return null;
        };

        /**
         *
         *
         *
         */
        XML.load = function (pathToFile, onload)
        {
            var xhr = isActiveXSupported("Microsoft.XMLHTTP") && new ActiveXObject("Microsoft.XMLHTTP") || new XMLHttpRequest(),
                async = ({}).toString.call(onload || {}) == "[object Function]";

            xhr.open("GET", pathToFile, async);

            if (async)
            {
                if (!!xhr.addEventListener)
                {
                    xhr.addEventListener("load", loaded, false);
                }
                else
                {
                    xhr.onreadystatechange = function ()
                    {
                        if (xhr.readyState == 4 && xhr.status == 200)
                        {
                            loaded();
                        }
                    };
                }
            }

            xhr.send(null);

            return async ? xhr : loaded(1);

            function loaded (ret)
            {
                var x = new XML((xhr.responseText||"").replace(/\s*<\?xml.*?\?>/,""));
                return ret ? x : onload(x);
            }
        };

        /**
         *    Ignore XML comments. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreComments = true;

        /**
         *    Ignore XML processing instructions. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreProcessingInstructions = true;

        /**
         *    Ignore whitespace. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.ignoreWhitespace = true;

        /**
         *    Pretty-print XML output with toXMLString() etc. (Default: true.)
         *
         *    @static
         *    @var Boolean
         */
        XML.prettyPrinting = true;

        /**
         *    Pretty indent level for child nodes. (Default: 2.)
         *
         *    @static
         *    @var Number
         */
        XML.prettyIndent = 2;

        //There are also three methods to more easily apply and restore settings for use, say, within a function.

        /**
         *    Get an Object containing the above settings.
         *
         *    @static
         *    @returns Object
         */
        XML.settings = function ()
        {
            return {
                ignoreComments:                 XML.ignoreComments,
                ignoreProcessingInstructions:   XML.ignoreProcessingInstructions,
                ignoreWhitespace:               XML.ignoreWhitespace,
                prettyPrinting:                 XML.prettyPrinting,
                prettyIndent:                   XML.prettyIndent
            };
        };

        /**
         *    Get an object containing the default settings.
         *
         *    @static
         *    @returns Object
         */
        XML.defaultSettings = function ()
        {
            return {
                ignoreComments:                 true,
                ignoreProcessingInstructions:   true,
                ignoreWhitespace:               true,
                prettyPrinting:                 true,
                prettyIndent:                   2
            };
        };

        /**
         *    Set XML settings from, e.g., an object returned by XML.settings().
         *
         *
         *    @static
         *    @param Object settings
         *    @returns void
         */
        XML.setSettings = function (settings)
        {
            var p;
            settings = settings || XML.settings();
            for (p in settings)
            {
                switch (p)
                {
                    case "ignoreComments":                   XML.ignoreComments = !!settings[p];
                    case "ignoreProcessingInstructions":     XML.ignoreProcessingInstructions = !!settings[p];
                    case "ignoreWhitespace":                 XML.ignoreWhitespace = !!settings[p];
                    case "prettyPrinting":                   XML.prettyPrinting = !!settings[p];
                    case "prettyIndent":                     XML.prettyIndent = parseInt(settings[p]) || 0;
                }
            }
            return null;
        };

        /**
         *
         *
         *    @static
         *    @param String name
         *    @returns Boolean
         */
        XML.hasOwnProperty = function (name)
        {
            return defaultXMLProperties.indexOf("," + name + ",") ===-1
                && hasOwnProperty.call(XML, name);
        };

        /**
         *
         *
         *    @static
         *    @param String name
         *    @returns Boolean
         */
        XML.propertyIsEnumerable = function (name)
        {
            return name !== "prototype"
                && name in XML
                && toString.call(XML[name]) != "[object Function]"
                && propertyIsEnumerable.call(XML, name);
        };

        /**
         *
         *
         *    @static
         *    @returns String
         */
        XML.toString = function ()
        {
            return "function XML() {\n [native code] \n}";
        };

        /**
         *
         *
         *    @param String | Namespace namespace
         *    @returns XML
         */
        XML.prototype.addNamespace = function (namespace)
        {
            AddInScopeNamespace.call(this, Namespace(namespace));
            return this;
        };

        /**
         *
         *
         *    @param String child
         *    @returns XML
         */
        XML.prototype.appendChild = function (child,isChildElement)
        {
            isChildElement = isChildElement !== undefined ? isChildElement : false;
            var children = Get.call(this, "*");
            children.Put(children.length(), child,isChildElement);
            return this;
        };

        /**
         *
         *
         *    @param String | AttributeName | QName attributeName
         *    @returns XML
         */
        XML.prototype.attribute = function (attributeName)
        {
            return Get.call(this, ToAttributeName(attributeName), true);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.attributes = function ()
        {
            return Get.call(this, ToAttributeName("*"));
        };

        /**
         *
         *
         *    @param String propertyName
         *    @returns XMLList
         */
        XML.prototype.child = function (propertyName)
        {
            var temporary;

            if (parseInt(propertyName)+"" == propertyName)
            {
                temporary = Get.call(this, "*");
                temporary = GetList.call(temporary, propertyName);
                return temporary || new XMLList();
            }

            temporary = ToXMLList( Get.call(this, propertyName) );

            return temporary;
        };

        /**
         *
         *
         *    @returns Number
         */
        XML.prototype.childIndex = function ()
        {
            var parent = this._Parent, q, l;

            if (!parent || this._Class === "attribute")
            {
                return -1;
            }

            for (q = 0, l = parent._Children.length; q < l; ++q)
            {
                if (parent._Children[q] === this)
                {
                    return q;
                }
            }

            return -1;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.children = function ()
        {
            return Get.call(this, "*");
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.comments = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "comment")
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns Boolean
         */
        XML.prototype.contains = function (value)
        {
            return this == value;
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.copy = function ()
        {
            return DeepCopy.call(this);
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XML.prototype.descendants = function (name)
        {
            return Descendants.call(this, name || "*");
        };

        /**
         *
         *
         *    @param String | QName | AttributeName name
         *    @returns XMLList
         */
        XML.prototype.elements = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = name;

            for (; i < l; ++i)
            {
                if (
                    this._Children[i]._Class === "element"
                    && (name.localName === "*" || name.localName === this._Children[i]._Name.localName)
                    && (name.uri == null || name.uri === this._Children[i]._Name.uri)
                )
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XML.prototype.hasOwnProperty = function (name)
        {
            return HasProperty.call(this, name) || (defaultXMLPrototype.indexOf("," + name +",") === -1 && hasOwnProperty.call(this, name));
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XML.prototype.hasComplexContent = function ()
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XML.prototype.hasSimpleContent = function ()
        {
            if ((",comment,processing-instruction,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return false;
                }
            }

            return true;
        };

        /**
         *
         *
         *    @returns Array
         */
        XML.prototype.inScopeNamespaces = function ()
        {
            var y = this, inScopeNS = {}, p, a = [];

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!inScopeNS[p])
                    {
                        inScopeNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y.parent();
            }

            if (this._DefaultNamespace)
            {
                inScopeNS[""] = this._DefaultNamespace;
            }

            for (p in inScopeNS)
            {
                a[a.length] = inScopeNS[p];
            }

            return a;
        };

        /**
         *
         *
         *    @param XML child1
         *    @param XML child2
         *    @returns XML | null
         */
        XML.prototype.insertChildAfter = function (child1, child2)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            /*
             //this is disabled, because it doesn't work in
             //Firefox according to the spec
             if (!child2)
             {
             Insert.call(this, 0, child1);
             return this;
             }
             else if (!child1)
             {
             Insert.call(this, 0, child2);
             return this;
             }
             else
             */

            if (!child1){
                Insert.call(this, 0, child2);
                return this;
            }
            if (!child2){
                Insert.call(this, 0, child1);
                return this;
            }

            if (child1 instanceof XML)
            {
                Insert.call(this, child1.childIndex() + 1, child2);
                return this;
            }

            return null;
        };

        /**
         *
         *
         *
         *    @param XML child1
         *    @param XML child2
         *    @returns XML | null
         */
        XML.prototype.insertChildBefore = function (child1, child2)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            /*
             //this is disabled, because it doesn't work in
             //Firefox according to the spec
             if (!child1)
             {
             Insert.call(this, this._Children.length, child2);
             return this;
             }
             else if (!child2)
             {
             Insert.call(this, this._Children.length, child1);
             return this;
             }
             else
             */

            if (child1 instanceof XML)
            {
                Insert.call(this, child1.childIndex(), child2);
                return this;
            }

            return null;
        };

        /**
         *
         *
         *    @returns Number
         */
        XML.prototype.length = function ()
        {
            return 1;
        };

        /**
         *
         *
         *    @returns String | null
         */
        XML.prototype.localName = function ()
        {
            return this._Name === null ? null : this._Name.localName;
        };

        /**
         *
         *
         *    return QName
         */
        XML.prototype.name = function ()
        {
            return this._Name;
        };

        /**
         *
         *
         *    @param String prefix
         *    @returns Namespace
         */
        XML.prototype.namespace = function (prefix)
        {
            var y = this, inScopeNS = {}, p;

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!inScopeNS[p])
                    {
                        inScopeNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y.parent();
            }

            if (prefix === undefined)
            {
                if ((",comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
                {
                    return null;
                }

                return GetNamespace(this._Name, inScopeNS);
            }

            prefix = ToString(prefix);

            for (p in inScopeNS)
            {
                if (inScopeNS[p].prefix === prefix)
                {
                    return inScopeNS[p];
                }
            }

            return null;
        };

        /**
         *
         *
         *    @returns Array
         */
        XML.prototype.namespaceDeclarations = function ()
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return [];
            }

            var a = [], y = this._Parent, ancestorNS = {}, p;

            while (y)
            {
                for (p in y._InScopeNamespaces)
                {
                    if (!ancestorNS[p])
                    {
                        ancestorNS[p] = y._InScopeNamespaces[p];
                    }
                }

                y = y._Parent;
            }

            for (p in this._InScopeNamespaces)
            {
                if (p != "" && (!ancestorNS[p] || ancestorNS[p].uri != this._InScopeNamespaces[p]))
                {
                    a[a.length] = this._InScopeNamespaces[p];
                }
                else if(p === "" && !this._Parent)
                {
                    a[a.length] = this._InScopeNamespaces[p];
                }
            }

            return a;
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.nodeKind = function ()
        {
            return this._Class;
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.normalize = function ()
        {
            for (var i = 0, l = this._Children.length; i < l;)
            {
                if (this._Children[i]._Class === "element")
                {
                    this._Children[i].normalize();
                    ++i;
                }
                else if (this._Children[i]._Class === "text")
                {
                    while (i+1 < this._Children.length && this._Children[i+1]._Class === "text")
                    {
                        this._Children[i]._Value = (this._Children[i]._Value || "") + (this._Children[i+1]._Value || "");
                        DeleteByIndex.call(this, i+1);
                    }

                    if (this._Children[i]._Value.length === 0)
                    {
                        DeleteByIndex.call(this, i);
                    }
                    else
                    {
                        ++i;
                    }
                }
                else
                {
                    ++i;
                }
            }

            return this;
        };

        /**
         *
         *
         *    @returns XML | null
         */
        XML.prototype.parent = function ()
        {
            return this._Parent;
        };

        /**
         *
         *
         *    @param String name
         *    @returns XMLList
         */
        XML.prototype.processingInstructions = function (name)
        {
            name = ToXMLName(name || "*");

            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "processing-instruction"
                    && (name.localName === "*" || name.localName === this._Children[i]._Name.localName)
                )
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.prependChild = function (value)
        {
            Insert.call(this, 0, value);
            return this;
        };


        XML.prototype.findFirstElement = function (value)
        {
            var list = [];
            list = this.elements(value)._Children;
            if(list.length == 0){
                var children = this.children();
                var xml;
                for(var i=0;i<children.length();i++){
                    xml = children[i];
                    var sublist = xml.findFirstElement(value);
                    if(sublist.length>0)
                        return sublist;
                }
            }
            return list;
        };


        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XML.prototype.propertyIsEnumerable = function (name)
        {
            return name == "0";
        };

        /**
         *
         *
         *    @param Namespace | String namespace
         *    @returns XML
         */
        XML.prototype.removeNamespace = function (namespace)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return this;
            }

            var ns = Namespace(namespace), thisNS = GetNamespace(this._Name, this._InScopeNamespaces), p, l;

            if (thisNS == ns)
            {
                return this;
            }

            /*
             //firefox does not remove the references to the
             //namespaces in attributes -- so we wont either
             for (p in this._Attributes)
             {
             if (GetNamespace(this._Attributes[p]._Name, this._InScopeNamespaces).uri == ns.uri)
             {
             this._Attributes[p]._Name = new QName(ns, this._Attributes[p].localName());
             }
             }
             //*/

            if (ns.prefix == undefined)
            {
                for (p in this._InScopeNamespaces)
                {
                    if (this._InScopeNamespaces[p].uri === ns.uri)
                    {
                        try{
                            this._InScopeNamespaces[p] = null;
                            delete this._InScopeNamespaces[p];
                        }catch(e){}
                    }
                }
            }
            else if (this._InScopeNamespaces[ns.prefix] && this._InScopeNamespaces[ns.prefix].uri === ns.uri)
            {
                try{
                    this._InScopeNamespaces[ns.prefix] = null;
                    delete this._InScopeNamespaces[ns.prefix];
                }catch(e){}
            }

            for (p = 0, l = this._Children.length; p < l; ++p)
            {
                if (this._Children[p]._Class === "element")
                {
                    this._Children[p].removeNamespace(ns);
                }
            }

            return this;
        };

        /**
         *
         *
         *    @param String propertyName
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.replace = function (propertyName, value)
        {
            if ((",attribute,comment,processing-instruction,text,").indexOf("," + this._Class + ",") > -1)
            {
                return this;
            }

            var c = value instanceof XML ? DeepCopy.call(value) : ToString(value), n, i, k;

            if (parseInt(propertyName)+"" == propertyName)
            {
                Replace.call(this, propertyName, c);
                return this;
            }

            /*
             Basically Firefox does not appear to follow the rules set forth in the spec
             so, we are just going to fix this so that we do what firefox does
             if the propertyName is not an integer:
             if value is a XMLList setChildren
             otherwise do nothing
             */

            if (c instanceof XMLList)
            {
                this.setChildren(c);
            }

            return this;

            /*
             Leave the rest of these rules in place, just in case
             */

            n = QName(propertyName);
            k = this._Children.length;

            while (--k > -1)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName===n.localName))
                    && (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri ))
                )
                {
                    if (i !== undefined)
                    {
                        DeleteByIndex.call(this, i);
                    }

                    i = k;
                }
            }

            if (i !== undefined)
            {
                Replace.call(this, i, c);
            }

            return this;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns XML
         */
        XML.prototype.setChildren = function (value)
        {
            this.Put("*", value);
            return this;
        };

        /**
         *
         *
         *    @param String name
         *    @returns void
         */
        XML.prototype.setLocalName = function (name)
        {
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._Name.localName = name instanceof QName ? name.localName : ToString(name);
        };

        /**
         *
         *
         *    @param QName | String name
         *    @returns null
         */
        XML.prototype.setName = function (name)
        {
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            if (name instanceof QName && name.uri == null)
            {
                name = name.localName;
            }

            var n = QName(name);

            if (this._Class === "processing-instruction")
            {
                n.uri = "";
            }

            this._DefaultNamespace = new Namespace(n.prefix, n.uri);

            this._Name = n;

            if (this._Class === "attribute")
            {
                if (this._Parent)
                {
                    AddInScopeNamespace.call(this._Parent, this._DefaultNamespace);
                }
            }
            else if (this._Class === "element")
            {
                AddInScopeNamespace.call(this, this._DefaultNamespace);
            }
            else if ((",comment,text,processing-instruction,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._Name = new QName(this._DefaultNamespace, this._Name.localName);

            return null;
        };

        /**
         *
         *
         *    @param Namespace | String ns
         *    @returns null
         */
        XML.prototype.setNamespace = function (ns)
        {
            //processing-instruction,
            if ((",comment,text,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            this._DefaultNamespace = Namespace(ns);

            this._Name = new QName(this._DefaultNamespace, this._Name.localName);

            if (this._Class === "attribute")
            {
                if (this._Parent)
                {
                    AddInScopeNamespace.call(this._Parent, this._DefaultNamespace);
                }
            }
            else if (this._Class === "element")
            {
                AddInScopeNamespace.call(this, this._DefaultNamespace);
            }

            return null;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XML.prototype.text = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;
            list._TargetObject = this;
            list._TargetProperty = null;

            for (; i < l; ++i)
            {
                if (this._Children[i]._Class === "text")
                {
                    list.Append(this._Children[i]);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.toString = function ()
        {
            return ToString(this);
        };

        /**
         *
         *
         *    @returns String
         */
        XML.prototype.toXMLString = function ()
        {
            return ToXMLString(this);
        };

        /**
         *
         *
         *    @returns XML
         */
        XML.prototype.valueOf = function ()
        {
            return this;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML | String Value
         *    @returns null
         *    @throws TypeError
         */
        XML.prototype.Put = function (PropertyName, Value)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                throw new TypeError();
            }

            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var c = (!(Value instanceof XML) || (",text,attribute,").indexOf("," + Value._Class+",") > -1)
                    ? ToString(Value)
                    : DeepCopy.call(Value),
                n = ToXMLName(PropertyName),
                s, i, l, a = null, primitiveAssign, k;

            if (n instanceof AttributeName)
            {
                if (!isXMLName(n._Name))
                {
                    return false;
                }

                if (c instanceof XMLList)
                {
                    if (c._Children.length === 0)
                    {
                        c = "";
                    }
                    else
                    {
                        s = ToString(c[0]);

                        for (i = 1, l = c._Children.length; i < l; ++i)
                        {
                            s += " " + ToString(c[i]);
                        }

                        c = s;
                    }
                }
                else
                {
                    c = ToString(c);
                }

                for (i in this._Attributes)
                {
                    if (
                        (n._Name.localName === this._Attributes[i]._Name.localName)
                        && (n._Name.uri === null || n._Name.uri === this._Attributes[i]._Name.uri)
                    )
                    {
                        if (a == null)
                        {
                            a = this._Attributes[i];
                        }
                        else
                        {
                            this.Delete(this._Attributes[i]._Name);
                        }
                    }
                }

                if (a == null)
                {
                    a = new XML();
                    a._Parent = this;
                    a._Class = "attribute";
                    a._Name = n._Name.uri == null
                        ? new QName(new Namespace(), n._Name)
                        : new QName(new Namespace(n._Name.uri), n._Name.localName);

                    this._Attributes[(a._Name._Prefix ? a._Name._Prefix + ":" : "") + a._Name.localName] = a;

                    AddInScopeNamespace.call(this, GetNamespace(a._Name));
                }

                a._Value = c;

                return null;
            }

            if (!isXMLName(n) && n.localName != "*")
            {
                return null;
            }

            i = undefined;

            primitiveAssign = !(c instanceof XML) && n.localName != "*";

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName===n.localName))
                    &&
                    (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                )
                {
                    if (i != undefined)
                    {
                        DeleteByIndex.call(this, ToString(i));
                    }
                    else
                    {
                        i = k;
                    }
                }
            }

            if (i == undefined)
            {
                i = this._Children.length;

                if (primitiveAssign)
                {
                    a = new XML();
                    a._Class = "element";
                    a._Parent = this;
                    a._Name = n.uri == null
                        ? new QName(GetDefaultNamespace(), n)
                        : new QName(n);

                    Replace.call(this, ToString(i), a);

                    AddInScopeNamespace.call(a, GetNamespace(a._Name));
                }
            }

            if (primitiveAssign)
            {
                s = ToString(c);

                if (s != "")
                {
                    Replace.call(this._Children[i], "0", s);
                }
            }
            else
            {
                Replace.call(this, ToString(i), c);
            }

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns null
         *    @throws TypeError
         */
        XML.prototype.Delete = function (PropertyName)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                throw new TypeError();
            }

            var n = ToXMLName(PropertyName), k, dp = 0, q = 0, l;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName)
                        &&
                        (n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri)
                    )
                    {
                        this._Attributes[k]._Parent = null;
                        try{
                            delete this._Attributes[k];
                        }catch(e){}
                    }
                }

                return true;
            }

            for (l = this._Children.length; q < l; ++q)
            {
                if (
                    (n.localName === "*" || (this._Children[q]._Class === "element" && this._Children[q]._Name.localName === n.localName))
                    &&
                    (n.uri == null || (this._Children[q]._Class === "element" && n.uri === this._Children[q]._Name.uri))
                )
                {
                    DeleteByIndex.call(this, q);
                    ++dp;
                }
                else if (dp > 0)
                {
                    this._Children[q - dp] = this._Children[q];
                }
            }


            return true;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns Boolean
         */
        XML.prototype.Equals = function (Value)
        {
            if (!(Value instanceof XML))
            {
                return false;
            }
            if (this._Class !== Value._Class)
            {
                return false;
            }
            if (this._Children.length !== Value._Children.length)
            {
                return false;
            }
            if (this._Value !== Value._Value)
            {
                return false;
            }
            if (this._Name !== null)
            {
                if (Value._Name === null)
                {
                    return false;
                }
                if (Value._Name.localName !== this._Name.localName)
                {
                    return false;
                }
                if (Value._Name.uri !== this._Name.uri)
                {
                    return false;
                }
            }
            else if (Value._Name !== null)
            {
                return false;
            }

            if (count(this._Attributes) !== count(Value._Attributes))
            {
                return false;
            }

            var a, b, k, l;

            for (k in this._Attributes)
            {
                a = this._Attributes[k];

                b = Value._Attributes[k];

                if (!b || b._Name.localName !== a._Name.localName || b._Name.uri !== a._Name.uri || b._Value !== a._Value)
                {
                    return false;
                }
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                a = this._Children[k];

                b = Value._Children[k];

                if (!arguments.callee.call(a, b))
                {
                    return false;
                }
            }

            return true;
        };

        //extensions

        /*
         * e4x.js
         *
         * A JavaScript library that implements the optional E4X features described in
         * ECMA-357 2nd Edition Annex A if they are not already implemented.
         *
         * 2010-03-13
         *
         * By Elijah Grey, http://eligrey.com
         * License: The X11/MIT license (see COPYING.md)
         *
         * Changes:
         *    By Sam Shull, http://samshull.blogspot.com
         *    Just a litlle simplifying for implementation
         */

        /*global document, XML, XMLList, DOMParser, XMLSerializer, XPathResult */

        /*jslint undef: true, nomen: true, eqeqeq: true, bitwise: true, regexp: true,
         newcap: true, immed: true, maxerr: 1000, maxlen: 90 */

        /**
         *
         *
         *
         */
        XML.prototype.domNode = function ()
        {
            return adoptNode(document, xmlToDomNode(this));
        };

        /**
         *
         *
         *
         */
        XML.prototype.domNodeList = function ()
        {
            if (this.length() < 0)
            {
                throw new Error();
            }

            return adoptNode(document, createDocumentFrom(this).documentElement).childNodes;
        };

        /**
         *
         *
         *
         */
        XML.prototype.xpath = function (xpathExp)
        {
            var res = new XMLList,
                i = 0, l = this.length(),
                xpr;

            if (l !== 1)
            {
                for (; i < l; ++i)
                {
                    res.Append(this[i].xpath(xpathExp));
                }

                return res;
            }

            xpr = evaluate(createDocumentFrom(this), xpathExp, this);

            for (l=xpr.length; i < l; ++i)
            {
                res.Append(ToXML(xpr[i]));
            }

            return res;
        };

        /**
         *
         *
         *
         */
        XML.prototype.transform = function (xslt, params)
        {
            if (!xslt instanceof XML)
            {
                throw new TypeError();
            }

            var doc, res, i, l = this.length(), c;

            if (l > 1)
            {
                res = new XMLList();
                for (i = 0; i < l; ++i)
                {
                    res.Append(this[i].transform(xslt, params));
                }
                return res;
            }

            return transform(this, xslt, params);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        function XMLList ($string)
        {
            if (!(this instanceof XMLList))
            {
                return ToXMLList($string || "");
            }

            this._Class = "XMLList";

            this._Value = undefined;


            this._TargetObject = null;

            this._TargetProperty = null;

            this._Children = [];

            this[0] = null;

            if ($string)
            {
                var list = ToXMLList($string), i = 0, l = list._Children.length;
                this._Value = list._Value;

                for (;i < l; ++i)
                {
                    this._Children[i] = this[i] = list._Children[i];
                }
            }
        }

        /**
         *
         *
         *    @static
         *    @returns String
         *    @throws TypeError
         */
        XMLList.toString = function ()
        {
            return "function XMLList() {\n [native code] \n}";
        };

        XMLList.prototype = new XML();

        var ignore = {xpath:1,domNodeList:1,transform:1};

        for (p in XMLList.prototype)
        {
            if (ignore[p])
            {
                continue;
            }

            XMLList.prototype[p] = (function(p)
            {
                return function ()
                {
                    if (this._Children.length != 1)
                    {
                        throw new TypeError("cannot call " + p + " method on an XML list with " + this._Children.length + " elements");
                    }

                    return XML.prototype[p].apply(this[0], arguments);
                };
            })(p);
        }

        try{
            delete XMLList.prototype._Attributes;
            delete XMLList.prototype._InScopeNamespaces;
        }catch(e){}

        /**
         *
         *
         *    @param String | AttributeName attributeName
         *    @returns XMLList
         */
        XMLList.prototype.attribute = function (attributeName)
        {
            return GetList.call(this, ToAttributeName(attributeName));
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.attributes = function ()
        {
            return GetList.call(this, ToAttributeName("*"));
        };

        /**
         *
         *
         *    @param String | QName propertyName
         *    @returns XMLList
         */
        XMLList.prototype.child = function (propertyName)
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                r = this[i].child(propertyName);

                if (r._Children.length > 0)
                {
                    list.Append(r);
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.children = function ()
        {
            return GetList.call(this, "*");
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.comments = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].comments();

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param XML value
         *    @returns Boolean
         */
        XMLList.prototype.contains = function (value)
        {
            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this[i] == value)
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.copy = function ()
        {
            return DeepCopyList.call(this);
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.descendants = function (name)
        {
            return DescendantsList.call(this, name || "*");
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.elements = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;
            list._TargetProperty = name;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].elements(name);

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String name
         *    @returns Boolean
         */
        XMLList.prototype.hasOwnProperty = function (name)
        {
            return HasProperty.call(this, name)
                || (defaultXMLListProperties.indexOf("," + name + ",") === -1 && hasOwnProperty.call(this, name));
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XMLList.prototype.hasComplexContent = function ()
        {
            if (this._Children.length === 0)
            {
                return false;
            }

            if (this._Children.length === 1)
            {
                return this[0].hasComplexContent();
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return true;
                }
            }

            return false;
        };

        /**
         *
         *
         *    @returns Boolean
         */
        XMLList.prototype.hasSimpleContent = function ()
        {
            if (this._Children.length === 1)
            {
                return this[0].hasSimpleContent();
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    return false;
                }
            }

            return true;
        };

        /**
         *
         *
         *    @returns Number
         */
        XMLList.prototype.length = function ()
        {
            return this._Children.length;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.normalize = function ()
        {
            for (var i = 0, l = this._Children.length; i < l;)
            {
                if (this[i]._Class === "element")
                {
                    this[i].normalize();
                    ++i;
                }
                else if (this[i]._Class === "text")
                {
                    while (i+1 < this._Children.length && this[i+1]._Class === "text")
                    {
                        this[i]._Value = (this[i]._Value || "") + (this[i+1]._Value || "");
                        this.Delete(i+1);
                    }

                    if (this[i]._Value.length === 0)
                    {
                        this.Delete(i);
                    }
                    else
                    {
                        ++i;
                    }
                }
                else
                {
                    ++i;
                }
            }

            return this;
        };

        /**
         *
         *
         *    @returns XML | undefined
         */
        XMLList.prototype.parent = function ()
        {
            if (this._Children.length === 0)
            {
                return undefined;
            }

            for (var parent = this[0]._Parent, i = 1, l = this._Children.length; i < l; ++i)
            {
                if (this[i]._Parent != parent)
                {
                    return undefined;
                }
            }

            return parent;
        };

        /**
         *
         *
         *    @param String | QName name
         *    @returns XMLList
         */
        XMLList.prototype.processingInstructions = function (name)
        {
            name = ToXMLName(name || "*");
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].processingInstructions(name);

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @param String | Number name
         *    @returns Boolean
         */
        XMLList.prototype.propertyIsEnumerable = function (name)
        {
            return parseInt(name) > 0 && parseInt(name) < this._Children.length;
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.text = function ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length, r;
            list._TargetObject = this;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    r = this[i].text();

                    if (r._Children.length > 0)
                    {
                        list.Append(r);
                    }
                }
            }

            return list;
        };

        /**
         *
         *
         *    @returns String
         */
        XMLList.prototype.toString = function ()
        {
            return ToString(this);
        };

        /**
         *
         *
         *    @returns String
         */
        XMLList.prototype.toXMLString = function ()
        {
            return ToXMLString(this);
        };

        /**
         *
         *
         *    @returns XMLList
         */
        XMLList.prototype.valueOf = function ()
        {
            return this;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @param XML Value
         *    @param isElement
         *    @returns null
         */
        XMLList.prototype.Put = function (PropertyName, Value,isChildElement)
        {
            isChildElement = isChildElement !== undefined ? isChildElement : false;
            var i = parseInt(PropertyName), r, y, l, z, parent, c, j = 0, q, t;

            if (i+"" == PropertyName)
            {
                r = ResolveValue.call(this._TargetObject);
                /* Firefox doesn't do this
                 if (r == null)
                 {
                 return null;
                 }
                 */
                if (i >= this._Children.length)
                {
                    if (r instanceof XMLList)
                    {
                        if (r.length() != 1)
                        {
                            return null;
                        }

                        r = r[0];
                    }

                    /* Firefox doesn't do this
                     if (r._Class != "element")
                     {
                     return null;
                     }
                     */
                    y = new XML();
                    y._Parent = r;
                    y._Name = this._TargetProperty;
                    y._Attributes = {};

                    if (this._TargetProperty instanceof AttributeName)
                    {
                        if (!!r && Get.call(r, y._Name).length() > 0)
                        {
                            return null;
                        }

                        y._Class = "attribute";
                    }
                    else if (!isChildElement && (this._TargetProperty == null || this._TargetProperty.localName === "*"))
                    {
                        y._Name = null;
                        y._Class = "text";
                    }
                    else
                    {
                        y._Class = "element";
                    }

                    if (y._Class != "attribute")
                    {
                        if (r)
                        {
                            j = 0;

                            if (i > 0)
                            {
                                while (j < r._Children.length-1 && r[j] !== this[i-1])
                                {
                                    ++j;
                                }
                            }
                            else
                            {
                                j = r._Children.length - 1;
                            }

                            Insert.call(r, j+1, y);
                        }

                        if (Value instanceof XMLList)
                        {
                            y._Name = Value._TargetProperty;
                        }
                        else if (Value instanceof XML)
                        {
                            y._Name = Value._Name;
                        }
                    }

                    this.Append(y);
                }

                if (!(Value instanceof XML) || Value._Class === "text" || Value._Class === "attribute")
                {
                    Value = ToString(Value);
                }

                if (this[i]._Class === "attribute")
                {
                    z = ToAttributeName(this[i]._Name);
                    this[i]._Parent.Put(z, Value);
                    this[i] = this[i]._Parent.attribute(z)[0];
                }
                else if (Value instanceof XMLList)
                {
                    //shallow copy?
                    c = Value;
                    parent = this[i]._Parent;

                    if (parent)
                    {
                        q = this[i].childIndex();
                        Replace.call(parent, q, c);
                        for (j = 0, l = c._Children.length; j < l; ++j)
                        {
                            c._Children[j] = c[j] = parent._Children[q+j];
                        }
                    }

                    if (c._Children.length === 0)
                    {
                        for (j = i + 1, l = this._Children.length; j < l; ++j)
                        {
                            this._Children[j-1] = this[j-1] = this[j]
                        }
                    }
                    else
                    {
                        for (j = this._Children.length; j > i; --j)
                        {
                            z = ToString(j + c._Children.length - 1);
                            this._Children[z] = this[z] = this[j];
                        }
                    }

                    for (j = 0, l = c._Children.length; j < l; ++j)
                    {
                        this._Children[i+j] = this[i+j] = c[j];
                    }

                }
                else if (Value instanceof XML || (",text,comment,processing-instruction").indexOf("," + this[i]._Class+",") > -1)
                {
                    parent = !!this[i] && this[i]._Parent;

                    if(parent)
                    {
                        q = this[i].childIndex();
                        Replace.call(parent, q, Value);
                        Value = parent._Children[q];
                    }

                    if (toString.call(Value) === "[object String]")
                    {
                        t = ToXML(Value);
                        t._Parent = this;
                        this._Children[i] = this[i] = t;
                    }
                    else
                    {

                    }
                }
                else
                {
                    this.Append(XMLList(Value));
                }
            }
            /* Firefox doesn't do this
             else if (this.length() <= 1)
             {
             if (this.length() === 0)
             {
             r = ResolveValueList.call(this);

             if (r == null || r.length() != 1)
             {
             return null;
             }

             this.Append(r);
             }
             else
             {
             this[0].Put(PropertyName, Value);
             }
             }*/

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @returns null
         */
        XMLList.prototype.Delete = function (PropertyName)
        {
            var i = parseInt(PropertyName), parent, q, l;

            if (i+"" == PropertyName)
            {
                if (i >= this._Children.length)
                {
                    return true;
                }

                parent = this[i]._Parent;

                if (parent)
                {
                    if (this[i]._Class = "attribute")
                    {
                        parent.Delete(ToAttributeName(this[i]._Name));
                    }
                    else
                    {
                        DeleteByIndex.call(parent, this[i].childIndex());
                    }
                }

                try{
                    this._Children.splice(PropertyName,1);
                    delete this[PropertyName];
                }catch(e){}

                for (q = i + 1, l = this._Children.length; q < l; ++q)
                {
                    this._Children[q-1] = this[q-1] = this[q];
                }
                return true;
            }
            /* Firefox won't do this
             for (q = 0, l = this._Children.length; q < l; ++q)
             {
             if (this[q]._Class === "element")
             {
             this[q].Delete(PropertyName);
             }
             }
             */
            return true;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns null
         */
        XMLList.prototype.Append = function (Value)
        {
            if (!(Value instanceof XML))
            {
                return null;
            }

            var i = this._Children.length, n = 1, j = 0;

            if (Value instanceof XMLList)
            {
                n = Value._Children.length;

                if (n == 0)
                {
                    return null;
                }

                this._TargetObject = Value._TargetObject;
                this._TargetProperty = Value._TargetProperty;

                for (;j < n; ++j)
                {
                    this._Children[i+j] = this[i+j] = Value[j];
                }
            }
            else
            {
                this._Children[i] = this[i] = Value;
            }

            return null;
        };

        /**
         *
         *
         *
         *    @access private
         *    @param XML Value
         *    @returns Boolean
         */
        XMLList.prototype.Equals = function (Value)
        {
            if (Value == undefined && this._Children.length === 0)
            {
                return true;
            }
            else if (Value instanceof XMLList && Value._Children.length === this._Children.length)
            {
                for (var i = 0, l = this._Children.length; i < l; ++i)
                {
                    if (!this[i].Equals(Value[i]))
                    {
                        return false;
                    }
                }
            }
            else if (this._Children.length === 1)
            {
                return this[0].Equals(Value);
            }

            return false;
        };

        /**
         *
         *
         *
         *    @access private
         *    @returns XMLList
         */
        function ResolveValueList ()
        {
            if (this._Children.length > 0)
            {
                return this;
            }

            if (this._TargetObject == null
                || this._TargetProperty == null
                || this._TargetProperty instanceof AttributeName
                || this._TargetProperty.localName === "*"
            )
            {
                return null;
            }

            var base = ResolveValue.call(this._TargetObject), target;

            if (base == null)
            {
                return null;
            }

            target = Get.call(base, this._TargetProperty);

            if (target._Children.length === 0)
            {
                if (base instanceof XMLList && base._Children.length > 1)
                {
                    return null;
                }

                base.Put(this._TargetProperty, "");

                target = Get.call(base, this._TargetProperty);
            }

            return target;
        };

        /**
         *
         *
         *    @param String | Namespace | QName prefix
         *    @param String uri
         *    @returns Namespace
         *    @throws TypeError
         */
        function Namespace (prefix, uri)
        {
            if (!(this instanceof Namespace))
            {
                return prefix && prefix instanceof Namespace
                    ? prefix
                    : new Namespace(prefix, uri);
            }

            if (uri === undefined && prefix === undefined)
            {
                this.prefix = "";
                this.uri = "";
            }
            else if (uri === undefined)
            {
                uri = prefix;
                prefix = undefined;

                if (uri instanceof Namespace)
                {
                    this.prefix = uri.prefix;
                    this.uri = uri.uri;
                }
                else if (uri instanceof QName && uri.uri !== null)
                {
                    this.uri = uri.uri;
                }
                else
                {
                    this.uri = ToString(uri);

                    if (this.uri == "")
                    {
                        this.prefix = "";
                    }
                }
            }
            else
            {
                if (uri instanceof QName)
                {
                    this.uri = uri.uri;
                }
                else
                {
                    this.uri = ToString(uri);
                }

                if (this.uri === "")
                {
                    if (prefix === undefined || ToString(prefix) === "")
                    {
                        this.prefix = "";
                    }
                    else
                    {
                        throw new TypeError("cannot define the prefix for an empty uri");
                    }
                }
                else if (prefix === undefined)
                {
                    this.prefix = undefined;
                }
                else
                {
                    this.prefix = ToString(prefix);
                }
            }
        }

        /**
         *
         *
         *    @var String
         */
        Namespace.prototype.prefix = undefined;

        /**
         *
         *
         *    @var String
         */
        Namespace.prototype.uri = undefined;

        /**
         *
         *
         *    @returns String
         */
        Namespace.prototype.toString = function ()
        {
            return this.uri;
        };

        /**
         *
         *
         *    @param Namespace | String | QName NameSpace
         *    @param String
         *    @returns QName
         */
        function QName (NameSpace, Name)
        {
            if (!(this instanceof QName))
            {
                return NameSpace instanceof QName
                    ? NameSpace
                    : new QName(NameSpace, Name);
            }

            if (Name === undefined)
            {
                Name = NameSpace;
                NameSpace = undefined;
            }

            if (Namespace instanceof QName)
            {
                if (Name === undefined)
                {
                    Name = Name.localName;
                }
            }

            Name = Name === undefined || Name === null
                ? ""
                : ToString(Name);

            if (NameSpace === undefined)
            {
                NameSpace = Name === "*" ? null : GetDefaultNamespace();
            }

            this.localName = Name;

            if (NameSpace == null)
            {
                this.uri = null;
            }
            else
            {
                NameSpace = Namespace(NameSpace);
                this.uri = NameSpace.uri;
                this._Prefix = NameSpace.prefix;
            }
        }

        /**
         *
         *
         *    @var String
         */
        QName.prototype.localName = undefined;

        /**
         *
         *
         *    @var String
         */
        QName.prototype.uri = undefined;

        /**
         *
         *
         *    @param Object InScopeNamespaces
         *    @returns Namespace
         *    @throws TypeError
         */
        function GetNamespace (q, InScopeNamespaces)
        {
            if(!q)
                return new Namespace();
            if (q.uri === null)
            {
                throw new TypeError();
            }

            InScopeNamespaces = InScopeNamespaces || {};

            var ns, p;

            for (p in InScopeNamespaces)
            {
                if (q.uri === InScopeNamespaces[p].uri)
                {
                    ns = InScopeNamespaces[p];

                    if (!!q._Prefix && q._Prefix === ns.prefix)
                    {
                        return ns;
                    }
                }
            }

            if (!ns)
            {
                ns = !!q._Prefix
                    ? new Namespace(q._Prefix, q.uri)
                    : new Namespace(q.uri);
            }

            return ns;
        };

        /**
         *
         *
         *    @returns String
         */
        QName.prototype.toString = function ()
        {
            return !!this.uri
                ? this.uri + "::" + this.localName
                : this.localName;
        };

        /**
         *
         *
         *    @param AttributeName | QName | String name
         *    @returns AttributeName
         */
        function AttributeName (name)
        {
            if (!(this instanceof AttributeName))
            {
                return name && (name instanceof AttributeName || name instanceof QName)
                    ? name
                    : new AttributeName(name);
            }

            this._Name = name instanceof QName
                ? name
                : new QName(new Namespace(GetDefaultNamespace()||undefined), name);
        }

        /**
         *
         *
         *    @var String
         */
        AttributeName.prototype.localName = undefined;

        /**
         *
         *
         *    @var String
         */
        AttributeName.prototype.uri = undefined;

        /**
         *
         *
         *    @returns String
         */
        AttributeName.prototype.toString = function ()
        {
            return "@" + (!!this._Name.uri
                        ? this._Name.uri + "::" + this._Name.localName
                        : this._Name.localName
                );
        };

        /**
         *
         *
         *
         */
        function AnyName ()
        {

        }

        /**
         *
         *
         *    @param mixed value
         *    @returns Boolean
         */
        function isXMLName (value)
        {
            if (value instanceof AttributeName)
            {
                return true;
            }

            try{
                var q = QName(value);
            }
            catch (e)
            {
                return false;
            }

            return !!q.localName && (!!q.localName.match(/^[\w\-]+$/i) || !!q.localName.match(/^[\w\-\:]+$/i));
        }

        /**
         *
         *
         *    @param mixed value
         *    @returns String
         *    @throws TypeError
         */
        function ToString (value)
        {
            var i = 0, l, s;

            if (value instanceof XMLList)
            {
                if (value.hasSimpleContent())
                {
                    s = "";

                    for (l = value.length(); i < l; ++i)
                    {
                        if (value[i]._Class != "comment" && value[i]._Class != "processing-instruction")
                        {
                            s += ToString(value[i]);
                        }
                    }

                    return s;
                }

                return ToXMLString(value);
            }
            else if (value instanceof XML)
            {
                if (value._Class === "attribute" || value._Class === "text")
                {
                    return value._Value;
                }

                if (value.hasSimpleContent())
                {
                    s = "";

                    for (l = value.length(); i < l; ++i)
                    {
                        if (value.child(i)._Class != "comment" && value.child(i)._Class != "processing-instruction")
                        {
                            s += ToString(value.child(i));
                        }
                    }

                    return s;
                }

                return ToXMLString(value);
            }
            else if (value instanceof AttributeName)
            {
                return "@" + ToString(value._Name);
            }

            return value === null || value === undefined
                ? ""
                : "" + value;
        }

        /**
         *
         *
         *    @param XML input
         *    @param Object AncestorNamespaces
         *    @param Number IndentLevel
         *    @returns String
         */
        function ToXMLString (input, AncestorNamespaces, IndentLevel)
        {
            var s = "", p = 0, temp, temp2, namespace, namespaceUnion,
                namespaceDeclarations = {}, attrAndNamespaces, prefixes, defaultSet;

            AncestorNamespaces = AncestorNamespaces || {};

            IndentLevel = Number(IndentLevel || 0);

            if (input instanceof XMLList)
            {
                temp = input.hasSimpleContent();

                temp2 = input.length();

                for (; p < temp2; ++p)
                {
                    if (p > 0)
                    {
                        s += "\r\n";
                    }

                    s += ToXMLString(input[p], AncestorNamespaces);
                }

                return s;
            }
            else if (input instanceof XML)
            {
                if (XML.prettyPrinting)
                {
                    //s += new Array(IndentLevel+1).join(" ");
                    for (; p < IndentLevel; ++p)
                    {
                        s += " ";
                    }
                }

                switch (input._Class)
                {
                    case "text":
                        return s + EscapeElementValue(XML.prettyPrinting ? trim(input._Value) : input._Value);

                    case "attribute":
                        return s + EscapeAttributeValue(input._Value);

                    case "comment":
                        return s + "<!--" + input._Value + "-->";

                    case "processing-instruction":
                        return s + "<?" + input._Name.localName + " " + input._Value + "?>";

                    default:
                        namespaceUnion = extend({}, AncestorNamespaces);

                        for (p in input._InScopeNamespaces)
                        {
                            temp = input._InScopeNamespaces[p];

                            if (!AncestorNamespaces[(temp.prefix||"")] || AncestorNamespaces[(temp.prefix||"")].uri != temp.uri)
                            {
                                namespaceUnion[(temp.prefix||"")] = namespaceDeclarations[(temp.prefix||"")] = new Namespace(temp);
                            }
                        }

                        if (!input._Parent)
                        {
                            namespaceUnion[(input._DefaultNamespace.prefix||"")] =
                                namespaceDeclarations[(input._DefaultNamespace.prefix||"")] = new Namespace(input._DefaultNamespace);
                        }
                        /*
                         //firefox doesn't do this
                         for (p in input._Attributes)
                         {
                         namespace = GetNamespace(input._Attributes[p]._Name, namespaceUnion);

                         if (namespace.prefix === undefined)
                         {
                         do {
                         namespace.prefix = !namespaceUnion[""] ? "" : newPrefix();
                         }
                         while(!!namespaceUnion[namespace.prefix]);
                         }

                         namespaceUnion[namespace.prefix] = namespaceDeclarations[namespace.prefix] = namespace;
                         }
                         */

                        s += "<";

                        namespace = GetNamespace(input._Name, namespaceDeclarations);

                        if (namespace.prefix)
                        {
                            s += namespace.prefix + ":";
                        }

                        s += input._Name ? input._Name.localName : "";

                        attrAndNamespaces = extend({}, input._Attributes, namespaceDeclarations);

                        defaultSet = false;

                        for (p in attrAndNamespaces)
                        {
                            s += " ";

                            if (attrAndNamespaces[p] instanceof XML)
                            {
                                temp = GetNamespace(attrAndNamespaces[p]._Name, AncestorNamespaces);

                                if (temp.prefix === undefined && !namespaceUnion[""])
                                {
                                    do{
                                        temp.prefix = !namespaceUnion[""] ? "" : newPrefix();
                                    }
                                    while(namespaceUnion[temp.prefix]);

                                    namespaceUnion[temp.prefix] = namespaceDeclarations[temp.prefix] = new Namespace(temp);
                                }

                                if (temp.prefix)
                                {
                                    s += temp.prefix + ":";
                                }

                                s += attrAndNamespaces[p].localName() + '="' + EscapeAttributeValue(attrAndNamespaces[p]._Value) + '"';
                            }
                            else
                            {
                                s += "xmlns";

                                if (!attrAndNamespaces[p].prefix && defaultSet)
                                {
                                    do{
                                        attrAndNamespaces[p].prefix = newPrefix();
                                    }
                                    while(!!namespaceUnion[attrAndNamespaces[p].prefix]);

                                    namespaceUnion[attrAndNamespaces[p].prefix] =
                                        namespaceDeclarations[attrAndNamespaces[p].prefix] =
                                            new Namespace(attrAndNamespaces[p]);

                                    s += ":" + attrAndNamespaces[p].prefix;
                                }
                                else if (!attrAndNamespaces[p].prefix && !defaultSet)
                                {
                                    defaultSet = true;
                                }
                                else if (attrAndNamespaces[p].prefix)
                                {
                                    s += ":" + attrAndNamespaces[p].prefix;
                                }

                                s += '="' + EscapeAttributeValue(attrAndNamespaces[p].uri) + '"';
                            }
                        }

                        temp = input._Children.length;

                        if (!temp)
                        {
                            return s + "/>";
                        }

                        s += ">";

                        temp2 = temp > 1 || (temp == 1 && input._Class !== "text");

                        names = (!!XML.prettyPrinting && !!temp2) ? IndentLevel + Number(XML.prettyIndent) : 0;

                        prefixes = !!XML.prettyPrinting && !!temp2;

                        for (p = 0; p < temp; ++p)
                        {
                            if (prefixes)
                            {
                                s += "\r\n";
                            }

                            if (input._Children[p])
                            {
                                s += ToXMLString(input._Children[p], namespaceDeclarations, names);
                            }
                        }

                        if (prefixes)
                        {
                            s += "\r\n";

                            for (p = 0; p < IndentLevel; ++p)
                            {
                                s += " ";
                            }
                        }

                        return s + "</" + (namespace.prefix ? namespace.prefix + ":" : "") + input._Name.localName + ">";
                }

                throw new TypeError();
            }
            else if (input === undefined || input === null)
            {
                throw new TypeError();
            }
            else if (toString.call(input) === "[object Object]")
            {
                return EscapeElementValue( input.valueOf().toString() );
            }

            return ToString(input);
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XML
         *    @throws SyntaxError | TypeError
         */
        function ToXML (s)
        {
            var x, div;

            if (s instanceof XMLList)
            {
                if (s.length() == 1)
                {
                    return s[0];
                }
            }
            else if (s instanceof XML)
            {
                return s;
            }
            else if ((",string,number,boolean,").indexOf("," + typeof(s)+",") > -1)
            {

                div = parse('<parent xmlns="' + GetDefaultNamespace() + '">' + s + '</parent>');

                x = ToXML(div.documentElement)

                if (x)
                {
                    if (x.length() == 0)
                    {
                        return new XML();
                    }
                    else if (x.length() == 1)
                    {
                        x.child(0)._Parent = null;
                        return x.child(0);
                    }
                }


                throw new SyntaxError("Failed to convert DOM object to XML");
            }
            else if (s.nodeType && !isNaN(s.nodeType))
            {
                return MapInfoItemToXML(s);
            }

            throw new TypeError();
        }

        /**
         *
         *
         *    @param DOMNode i
         *    @returns XML
         *    @throws TypeError
         */
        function MapInfoItemToXML (i,n)
        {
            var x = new XML(), temp, temp2, temp3, isNScheck = isNSDef, j, l, xmlChild;

            x._Parent = null;

            switch (i.nodeType)
            {
                case TEXT_NODE:
                case CDATA_SECTION_NODE:
                    x._Class = "text";
                    x._Value = "";
                    temp = i;

                    while (temp && (temp.nodeType === TEXT_NODE || temp.nodeType === CDATA_SECTION_NODE))
                    {
                        x._Value += temp.textContent || temp.text || temp.data;
                        temp = temp.nextSibling;
                        if (n && (n.n || n.n == 0))
                        {
                            ++n.n;
                        }
                    }


                    if (XML.ignoreWhitespace && !x._Value.match(/\S+/))
                    {
                        return null;
                    }

                    return x;

                    break;
                case COMMENT_NODE:
                    if (XML.ignoreComments)
                    {
                        return null;
                    }

                    x._Class = "comment";
                    x._Value = i.data || i.textContent || i.text || "";

                    return x;

                    break;
                case PROCESSING_INSTRUCTION_NODE:
                    if (XML.ignoreProcessingInstructions)
                    {
                        return null;
                    }

                    x._Class = "processing-instruction";
                    x._Name = new QName("", i.target);
                    x._Value = i.data || i.textContent || i.text || "";

                    return x;

                    break;
                case ATTRIBUTE_NODE:
                    x._Class = "attribute";

                    temp = i.nodeName.match(/(([\w\-]+):)?([\w\-]+)/);

                    if ( temp[1] )
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace(temp[2]);
                        }
                        else
                        {
                            temp3 = n;//hack for ie -- stupid ie

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == ("xmlns:" + temp[2]))
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }
                        x._DefaultNamespace = new Namespace( temp[2], temp2 );
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }
                    else
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace("");
                        }
                        else
                        {
                            temp3 = i.parentNode;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == "xmlns")
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }

                        x._DefaultNamespace = new Namespace("", temp2);
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }

                    x._Value = i.value || null;

                    return x;

                    break;
                case ELEMENT_NODE:
                    x._Class = "element";
                    temp = i.nodeName.match(/(([\w\-]+):)?([\w\-]+)/);

                    if ( temp[1] )
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace(temp[2]);
                        }
                        else
                        {
                            temp3 = i;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == ("xmlns:" + temp[2]))
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }
                        x._DefaultNamespace = new Namespace( temp[2], temp2 );
                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }
                    else
                    {
                        temp2 = undefined;

                        if (!!i.lookupNamespace)
                        {
                            temp2 = i.lookupNamespace("");
                        }
                        else
                        {
                            temp3 = i;

                            while (!temp2 && !!temp3 && !!temp3.attributes)
                            {
                                for (j = 0, l = temp3.attributes.length; j < l; ++j)
                                {
                                    if (temp3.attributes[j].nodeName == "xmlns")
                                    {
                                        temp2 = temp3.attributes[j].value || temp3.attributes[j].nodeValue;
                                        break;
                                    }
                                }

                                temp3 = temp3.parentNode;
                            }
                        }

                        x._DefaultNamespace = new Namespace("", temp2);

                        x._Name = new QName( x._DefaultNamespace, temp[3] );
                    }

                    for (temp = 0, temp2 = i.attributes.length; temp < temp2; ++temp)
                    {
                        if (temp3 = isNScheck.exec(i.attributes[temp].nodeName))
                        {
                            x._InScopeNamespaces[temp3[1]] = new Namespace(temp3[1], i.attributes[temp].value);
                        }
                        else if (i.attributes[temp].nodeName === "xmlns")
                        {
                            x._InScopeNamespaces[""] = new Namespace(i.attributes[temp].value);
                        }
                        else
                        {
                            x._Attributes[i.attributes[temp].nodeName] = MapInfoItemToXML(i.attributes[temp], i);
                        }
                    }

                    j = 0;
                    xmlChild = 0;
                    temp = i.childNodes.length;

                    while (j < temp)
                    {
                        n = {n:-1};
                        if (temp3 = MapInfoItemToXML(i.childNodes[j], n))
                        {
                            //even though it is not written this way in the spec
                            //this is how it works in Firefox
                            x._Children[xmlChild] = temp3;
                            x._Children[xmlChild]._Parent = x;

                            if (temp3._Class === "text" && n.n > 0)
                            {
                                j = j + n.n;
                            }

                            ++xmlChild;
                        }

                        ++j;
                    }

                    x._Value = i.textContent || i.text || i.data || "";

                    x._Length = xmlChild;

                    return x;

                    break;
                case DOCUMENT_NODE:
                //firefox won't do this
                //return MapInfoItemToXML(document.documentElement);
                //break;
                case ENTITY_REFERENCE_NODE:
                    throw new TypeError();
                    break;
                default:
                    return null;
                    break;
            }
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XML
         *    @throws TypeError
         */
        function ToXMLList (s)
        {
            var e,x,list,i,l;

            if (s instanceof XMLList)
            {
                return s;
            }
            else if (s instanceof XML)
            {
                list = new XMLList();
                list._Children[0] = list[0] = s;
                list._TargetObject = x._Parent;
                list._TargetProperty = x._Name;

                return list;
            }
            else if ((",string,boolean,number,").indexOf("," + typeof(s)+",") === -1)
            {
                throw new TypeError();
            }

            e = parse('<parent xmlns="' + GetDefaultNamespace() + '">' + s + '</parent>');
            x = ToXML(e.documentElement);
            list = new XMLList();
            i = 0;
            l = x._Children.length;

            list._TargetObject = null;

            for (;i < l; ++i)
            {
                x._Children[i]._Parent = null;
                list._Children[i] = list[i] = x._Children[i];
            }


            return list;
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns XMLList
         *    @throws TypeError
         */
        function ToAttributeName (s)
        {
            if (s === "*")
            {
                return new AttributeName(new QName(null, "*"));
            }
            else if (s instanceof QName)
            {
                return new AttributeName(s);
            }
            else if (s instanceof AttributeName)
            {
                return s;
            }

            switch (typeof(s))
            {
                case "undefined":
                case "null":
                case "boolean":
                case "number":
                    throw new TypeError();
                    break;
                case "string":
                    return new AttributeName(new QName(null, (s + "").replace(/^@/,"")));
                    break;
                case "object":
                    return new AttributeName(new QName(null, ToString(s)));
                    break;
            }
        }

        /**
         *
         *
         *    @param mixed s
         *    @returns QName | AttributeName
         *    @throws TypeError
         */
        function ToXMLName (s)
        {
            if (s instanceof QName || s instanceof AttributeName)
            {
                return s;
            }
            else if (s === "*")
            {
                return new QName("*");
            }

            switch (typeof(s))
            {
                case "undefined":
                case "null":
                case "boolean":
                case "number":
                    throw new TypeError();
                    break;
                case "string":
                    if (s.charAt(0) === "@")
                    {
                        return ToAttributeName( s.substr(0) );
                    }

                    return new QName(s);

                    break;
                case "object":
                    return ToXMLName( ToString(s) );
                    break;
            }
        }

        /**
         *
         *
         *    @returns String
         */
        function GetDefaultNamespace ()
        {
            return !!defaultNamespace && defaultNamespace.uri || "";
        }

        /**
         *
         *
         *    @param String s
         *    @returns String
         */
        function EscapeElementValue (s)
        {
            return ((s||"")+"").replace(/./g, function (c)
            {
                switch (c)
                {
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    default:
                        return c;
                }
            });
        }

        /**
         *
         *
         *
         *    @param String s
         *    @returns String
         */
        function EscapeAttributeValue (s)
        {
            return ((s||"")+"").replace(/./g, function (c)
            {
                switch (c)
                {
                    case '"':
                        return "&quot;";
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    case "\r":
                        return "&#xA;";
                    case "\n":
                        return "&#xD;";
                    case "\t":
                        return "&#x9;";
                    default:
                        return c;
                }
            });
        }

        /**
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function Get (PropertyName)
        {
            if (this instanceof XMLList)
            {
                return GetList.call(this, PropertyName);
            }

            if (parseInt(PropertyName)+"" == PropertyName)
            {
                return GetList.call(ToXMLList(this), PropertyName );
            }

            var n = ToXMLName(PropertyName),
                list = new XMLList(), p, l;

            list._TargetObject = this;
            list._TargetProperty = n;

            if (n instanceof AttributeName)
            {
                for (p in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[p]._Name.localName)
                        &&
                        (n._Name.uri == null || n._Name.uri === this._Attributes[p]._Name.uri)
                    )
                    {
                        list.Append(this._Attributes[p]);
                    }
                }
            }
            else
            {
                for (p = 0, l = this._Children.length; p < l; ++p)
                {
                    if (
                        (n.localName === "*" || (this._Children[p]._Class === "element" && this._Children[p]._Name.localName === n.localName))
                        &&
                        (n.uri == null || (this._Children[p]._Class === "element" && n.uri === this._Children[p]._Name.uri))
                    )
                    {
                        list.Append(this._Children[p]);
                    }
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName P
         *    @returns Boolean
         */
        function HasProperty (P)
        {
            if (this instanceof XMLList)
            {
                return HasPropertyList.call(this, P);
            }

            if (parseInt(P) == P)
            {
                return P == "0";
            }

            var n = ToXMLName(P), k, l;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (
                            n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName
                        ) &&
                        (
                            n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri
                        )
                    )
                    {
                        return true;
                    }
                }

                return false;
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName === n.localName))
                    &&
                    (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                )
                {
                    return true;
                }
            }

            return false;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns Boolean
         *    @throws TypeError
         */
        function DeleteByIndex (PropertyName)
        {
            var i = parseInt(PropertyName);//, q = i + 1, l = this._Children.length;

            if (i == PropertyName)
            {
                if (!!this._Children[i])
                {
                    this._Children[i]._Parent = null;

                    this._Children[i] = null;

                    this._Children.splice(i, 1);

                    /*
                     for (;q < l;++q)
                     {
                     this._Children[q-1] = this._Children[q];
                     }
                     */
                }

                return true;
            }

            throw new TypeError();
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XML
         */
        function DeepCopy ()
        {
            if (this instanceof XMLList)
            {
                return DeepCopyList.call(this);
            }

            var y = new XML(), i, l;//, c, t;

            y._Class = this._Class;
            y._Name = this._Name;
            y._DefaultNamespace = this._DefaultNamespace ? new Namespace(this._DefaultNamespace) : null;
            y._Value = this._Value;
            y._Parent = null;

            for (i in this._InScopeNamespaces)
            {
                y._InScopeNamespaces[i] = new Namespace(this._InScopeNamespaces.prefix, this._InScopeNamespaces.uri);
            }

            for (l in this._Attributes)
            {
                //y._Attributes[i] = arguments.callee.call(this._Attributes[i]);
                //not part of the spec
                y._Attributes[i] = this._Attributes[l].copy();
                y._Attributes[i]._Parent = y;
            }

            for (i = 0, l = this._Children.length; i < l; ++i)
            {
                y._Children[i] = this._Children[i].copy();
                y._Children[i]._Parent = y;
            }

            return y;
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XML
         */
        function ResolveValue ()
        {
            if (this instanceof XMLList)
            {
                return ResolveValueList.call(this);
            }
            return this instanceof XML ? this : null;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function Descendants (PropertyName)
        {
            if (this instanceof XMLList)
            {
                return DescendantsList.call(this, PropertyName);
            }

            var n = ToXMLName(PropertyName),
                list = new XMLList(),
                k, l, dq;

            list._TargetObject = null;

            if (n instanceof AttributeName)
            {
                for (k in this._Attributes)
                {
                    if (
                        (n._Name.localName === "*" || n._Name.localName === this._Attributes[k]._Name.localName)
                        &&
                        (n._Name.uri == null || n._Name.uri === this._Attributes[k]._Name.uri)
                    )
                    {
                        list.Append(this._Attributes[k]);
                    }
                }
            }

            for (k = 0, l = this._Children.length; k < l; ++k)
            {
                if (
                    (n.localName === "*" || (this._Children[k]._Class === "element" && this._Children[k]._Name.localName === n.localName))
                    &&
                    (n.uri == null || (this._Children[k]._Class === "element" && n.uri === this._Children[k]._Name.uri))
                )
                {
                    list.Append(this._Children[k]);
                }

                dq = this._Children[k].descendants(n);

                if (dq.length() > 0)
                {
                    list.Append(dq);
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML Value
         *    @returns null
         *    @throws TypeError | Error
         */
        function Insert (PropertyName, Value)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return false;
            }

            var i = parseInt(PropertyName), n, j;

            if (i+"" != PropertyName)
            {
                throw new TypeError("'" + i + "' != '" + PropertyName + "'");
            }

            if (Value === this || indexOf("," + this, Value.descendants("*")) > -1)
            {
                throw new Error();
            }

            n = Value.length();

            for (j = this._Children.length - 1; j >= i; --j)
            {
                this._Children[ j + n ] = this._Children[j];
            }


            if (Value instanceof XMLList)
            {
                for (j = 0; j < n; ++j)
                {
                    Value[j]._Parent = this;
                    this._Children[i + j] = Value[j];
                }
            }
            else
            {
                Replace.call(this, i, Value);
            }

            return null;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @param XML Value
         *    @returns null
         *    @throws TypeError
         */
        function Replace (PropertyName, Value)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var i = parseInt(PropertyName), t;

            if (i+"" != PropertyName)
            {
                throw new TypeError("'" + i + "' != '" + PropertyName + "'");
            }

            if (i >= this._Children.length)
            {
                PropertyName = this._Children.length;
            }

            if (Value instanceof XMLList)
            {
                DeleteByIndex.call(this, PropertyName);
                Insert.call(this, PropertyName, Value);
            }
            else if (Value instanceof XML
                && Value._Class === "element"
                && (",element,comment,processing-instruction,text").indexOf("," + Value._Class + ",") > -1
            )
            {
                Value._Parent = this;

                if (this._Children[PropertyName])
                {
                    this._Children[PropertyName]._Parent = null;
                }

                this._Children[PropertyName] = Value;
            }
            else
            {
                t = new XML();
                t._Parent = this;
                t._Value = ToString(Value);

                if (this._Children[PropertyName])
                {
                    this._Children[PropertyName]._Parent = null;
                }

                this._Children[PropertyName] = t;
            }
        };

        /**
         *
         *
         *
         *    @access private
         *    @param String | Namespace NameSpace
         *    @returns null
         */
        function AddInScopeNamespace (NameSpace)
        {
            if ((",text,comment,processing-instruction,attribute,").indexOf("," + this._Class + ",") > -1)
            {
                return null;
            }

            var match = null, p;

            if (NameSpace.prefix == "" && this._Name.uri == "")
            {
                return null;
            }

            for (p in this._InScopeNamespaces)
            {
                if (NameSpace.prefix === this._InScopeNamespaces[p].prefix)
                {
                    match = this._InScopeNamespaces[p];
                }
            }

            if (match && match.uri != NameSpace.uri)
            {
                this._InScopeNamespaces[match.prefix] = null;
                try{
                    delete this._InScopeNamespaces[match.prefix];
                }catch(e){}
            }

            this._InScopeNamespaces[NameSpace.prefix] = NameSpace;

            if (this._Name.prefix === NameSpace.prefix)
            {
                this._Name.prefix = undefined;
            }

            for (p in this._Attributes)
            {
                if (this._Attributes[p]._Name.prefix = NameSpace.prefix)
                {
                    this._Attributes[p]._Name.prefix = undefined;
                }
            }

            //do this in order to ensure namespace integrity
            /*match = parse(this.toXMLString());
             this._Node = !!this._Node.parentNode
             ? this._Node.parentNode.replaceChild(match.documentElement, this._Node)
             : match;*/
        }

        /**
         *
         *
         *    @access private
         *    @param String | Number name
         *    @returns Boolean
         */
        function HasPropertyList (name)
        {
            if (ToString( parseInt(name) ) === name)
            {
                return parseInt(name) < this._Children.length;
            }

            for (var i = 0, l = this._Children.length; i < l; ++i)
            {
                if (this[i]._Class === "element" && this[i].hasOwnProperty(name))
                {
                    return true;
                }
            }

            return false;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | Number | QName PropertyName
         *    @returns XMLList
         */
        function GetList (PropertyName)
        {
            if (parseInt(PropertyName)+"" == PropertyName)
            {
                return this[PropertyName];
            }

            var list = new XMLList(), i = 0, l = this._Children.length, temp;
            list._TargetObject = this;
            list._TargetProperty = PropertyName;

            for (;i < l; ++i)
            {
                if (this._Children[i]._Class === "element")
                {
                    temp = Get.call(this._Children[i], PropertyName);

                    if (temp._Children.length > 0)
                    {
                        list.Append(temp);
                    }
                }
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @returns XMLList
         */
        function DeepCopyList ()
        {
            var list = new XMLList(), i = 0, l = this._Children.length;

            list._TargetObject = this._TargetObject;
            list._TargetProperty = this._TargetProperty;
            list._Class = this._Class;
            list._Value = this._Value;

            for (;i < l; ++i)
            {
                list.Append(DeepCopy.call(this[i]));
            }

            return list;
        }

        /**
         *
         *
         *
         *    @access private
         *    @param String | QName PropertyName
         *    @returns XMLList
         */
        function DescendantsList (PropertyName)
        {
            var list = new XMLList(), i = 0, l = this._Children.length, temp;

            for (; i < l; ++i)
            {
                if (this[i]._Class === "element")
                {
                    if ((temp = Descendants.call(this[i], "*")) && temp.length() > 0)
                    {
                        list.Append(temp);
                    }
                }
            }

            return list;
        }

        /**
         *    http://blog.stevenlevithan.com/archives/faster-trim-javascript
         *
         *
         *    @param String s
         *    @returns String
         */
        function trim (str)
        {
            if(!str)
                return str;
            var    str = str.replace(/^\s\s*/, ""),
                ws = /\s/,
                i = str.length;
            while (ws.test(str.charAt(--i)));
            return str.slice(0, i + 1);
        }

        /**
         *    Generates a prefix for a QName that is not already
         *    a property of the optional argument
         *
         *    @param Object prefixes
         *    @returns String
         */
        function newPrefix (prefixes)
        {
            prefixes = prefixes || {};

            var num = Math.random()
                .toString()
                .substr(2)
                .replace(/.{2}/g, function (a)
                {
                    a = Number(a);
                    return (a > 90 ? 90 : (a < 65 ? 65 : a)) + "";
                });

            num = String.fromCharCode(
                Number(num.substr(0, 2)) & 0xFF,
                Number(num.substr(2, 2)) & 0xFF,
                Number(num.substr(4, 2)) & 0xFF,
                Number(num.substr(6, 2)) & 0xFF,
                Number(num.substr(8, 2)) & 0xFF,
                Number(num.substr(10, 2)) & 0xFF
            ).toLowerCase();

            while (num in prefixes)
            {
                num = arguments.callee(prefixes);
            }

            return num;
        }

        /**
         *
         *
         *    @param String str
         *    @returns DOMNode
         *    @throws SyntaxError
         */
        function parse (str)
        {
            var xmlDoc, success = true;

            if (isActiveXSupported("Microsoft.XMLDOM")) //Internet Explorer
            {
                try{
                    xmlDoc                      = new ActiveXObject("Microsoft.XMLDOM");
                    xmlDoc.async                = 'false';
                    xmlDoc.preserveWhiteSpace   = true;
                    xmlDoc.resolveExternals     = false;
                    xmlDoc.validateOnParse         = false;
                    xmlDoc.setProperty('ProhibitDTD', false);
                    success = xmlDoc.loadXML(str);
                }catch(e){}
            }
            else
            {
                try{//Firefox, Mozilla, Opera, etc.
                    xmlDoc = new DOMParser();
                    xmlDoc = xmlDoc.parseFromString(str, "text/xml");
                }catch(e){}
            }

            if (!success || !xmlDoc || xmlDoc.documentElement.nodeName == "parsererror")
            {
                throw new SyntaxError(!!xmlDoc && xmlDoc.documentElement.childNodes[0].nodeValue);
            }

            return xmlDoc;
        }

        /**
         *
         *
         *    @param Object obj
         *    @returns Number
         */
        function count (obj)
        {
            if ("__count__" in obj)
            {
                return obj.__count__;
            }

            var i = 0, k;

            for (k in obj)
            {
                if (obj.hasOwnProperty(k))
                {
                    ++i;
                }
            }

            return i;
        }

        /**
         *
         *
         *    @param Object obj
         *    @param XMLList list
         *    @returns Number
         */
        function indexOf (obj, list)
        {
            for (var i = 0, l = list.length(); i < l; ++i)
            {
                if (list[i].Equals(obj))
                {
                    return i;
                }
            }

            return -1;
        }

        /**
         *
         *
         *    @param mixed obj
         *    @param mixed ...
         *    @returns mixed
         */
        function extend (obj)
        {
            for (var p, i = 1, l = arguments.length; i < l; ++i)
            {
                for (p in arguments[i])
                {
                    obj[p] = arguments[i][p];
                }
            }

            return obj;
        }

        /**
         *
         *
         *
         */
        function createDocumentFrom (xml)
        {
            return parse(xml.length() == 1 ? xml.toXMLString() : "<x>" + xml.toXMLString() + "</x>");
        }

        /**
         *
         *
         *
         */
        function xmlToDomNode (xml)
        {
            switch (xml.nodeKind())
            {
                case "element":
                    return createDocumentFrom(xml).documentElement;

                case "text":
                    return xmlDoc.createTextNode(xml.toString());

                case "comment":
                    return xmlDoc.createComment(xml.toString().slice(4, -3));

                case "processing-instruction":
                    return xmlDoc.createProcessingInstruction(
                        xml.localName(),
                        xml.toString().slice(2, -2).replace(piName, "")
                    );

                case "attribute":
                    return createAttributeNS(xml);
            }
            return null;
        }

        function adoptNode (doc, node)
        {
            if (!!doc.adoptNode)
            {
                return doc.adoptNode(node);
            }

            var b = doc.documentElement || doc.body;
            return b.removeChild(b.appendChild(node));
        }

        function evaluate (doc, expr, xml)
        {
            var res, l, n = "";

            if (!!doc.evaluate)
            {
                res = doc.evaluate(
                    expr,
                    doc,
                    doc.createNSResolver(doc),
                    XPathResult.ORDERED_NODE_ITERATOR_TYPE,
                    null
                );

                l = [];

                while(n = res.iterateNext())
                {
                    l[l.length] = n;
                }

                return l;
            }

            if ("setProperty" in doc){

                res = allNamespaces(xml);

                if (count(res))
                {
                    for (l in res)
                    {
                        n += " xmlns:" + l + '="' + EscapeAttributeValue(res[l]) + '"';
                    }

                    doc.setProperty('SelectionNamespaces', n.substr(1));
                }

                doc.setProperty("SelectionLanguage", "XPath");
            }

            return isActiveXSupported("Microsoft.XMLDOM") && doc.selectNodes(expr);
        }

        function isActiveXSupported(type) {
            try {
                new ActiveXObject(type);
                return true;
            } catch (e) {
                return false;
            }
        }

        function allNamespaces (xml, un)
        {
            var ns = un || {},
                i = 0,
                c = xml.children(),
                l = c.length(),
                n = un == undefined
                    ? inscope(xml)
                    : xml._InScopeNamespaces,
                p;

            for (;i < l; ++i)
            {
                ns = arguments.callee(c[i], ns);
            }

            for (p in n)
            {
                if (n[p].prefix)
                {
                    ns[n[p].prefix] = n[p].uri;
                }
            }

            return ns;
        }

        function inscope (xml)
        {
            var ns = {},
                i = 0,
                n = xml.inScopeNamespaces(),
                l = n.length;

            for (;i < l; ++i)
            {
                if (n[i].prefix)
                {
                    ns[n[i].prefix] = n[i].uri;
                }
            }

            return ns;
        }

        function createAttributeNS (xml)
        {
            var ns = xml.namespace(),
                node = !!xmlDoc.createAttributeNS
                    ? xmlDoc.createAttributeNS(ns.uri, xml.localName())
                    : xmlDoc.createAttribute((ns.prefix ? ns.prefix + ":" : "" ) + xml.localName());

            node.nodeValue = xml.toString();
            return node;
        }

        function transform (xml, style, params)
        {
            var xsl, res, i = 0, l = (params||[]).length;

            if (!window.XSLTProcessor)
            {
                //TODO: Need to create a way to set parameters on an IE stylesheet
                //XSLProcessor
                //http://msdn.microsoft.com/en-us/library/ms757015%28v=VS.85%29.aspx
                //http://msdn.microsoft.com/en-us/library/ms763679%28VS.85%29.aspx
                //http://msdn.microsoft.com/en-us/library/ms754594%28v=VS.85%29.aspx

                res = createDocumentFrom(xml).transformNode(createDocumentFrom(style));

                return !!res && ToXML(res) || null;
            }

            xsl = new XSLTProcessor();

            xsl.importStyleSheet(createDocumentFrom(style));

            for (; i < l; ++i)
            {
                res = params[i];
                xsl.setParameter(res.namespaceURI, res.localName, res.value);
            }

            res = xsl.transformToDocument(createDocumentFrom(doc))

            return !!res && ToXML(res) || null;
        }

        for (p in XML.prototype)
        {
            defaultXMLPrototype += p + ",";
        }

        for (p in XMLList.prototype)
        {
            defaultXMLListPrototype += p + ",";
        }

        /**
         *
         *
         *
         */
        window.XML              = XML;
        window.XMLList          = XMLList;
        window.QName            = QName;
        window.Namespace        = Namespace;
        window.isXMLName        = isXMLName;
        window.AttributeName    = AttributeName;

    })();
}

/***** xregexp.js *****/

/*!
 * XRegExp v2.0.0
 * (c) 2007-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 */

/**
 * XRegExp provides augmented, extensible JavaScript regular expressions. You get new syntax,
 * flags, and methods beyond what browsers support natively. XRegExp is also a regex utility belt
 * with tools to make your client-side grepping simpler and more powerful, while freeing you from
 * worrying about pesky cross-browser inconsistencies and the dubious `lastIndex` property. See
 * XRegExp's documentation (http://xregexp.com/) for more details.
 * @module xregexp
 * @requires N/A
 */
var XRegExp;

// Avoid running twice; that would reset tokens and could break references to native globals
XRegExp = XRegExp || (function (undef) {
    "use strict";

/*--------------------------------------
 *  Private variables
 *------------------------------------*/

    var self,
        addToken,
        add,

// Optional features; can be installed and uninstalled
        features = {
            natives: false,
            extensibility: false
        },

// Store native methods to use and restore ("native" is an ES3 reserved keyword)
        nativ = {
            exec: RegExp.prototype.exec,
            test: RegExp.prototype.test,
            match: String.prototype.match,
            replace: String.prototype.replace,
            split: String.prototype.split
        },

// Storage for fixed/extended native methods
        fixed = {},

// Storage for cached regexes
        cache = {},

// Storage for addon tokens
        tokens = [],

// Token scopes
        defaultScope = "default",
        classScope = "class",

// Regexes that match native regex syntax
        nativeTokens = {
            // Any native multicharacter token in default scope (includes octals, excludes character classes)
            "default": /^(?:\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9]\d*|x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|c[A-Za-z]|[\s\S])|\(\?[:=!]|[?*+]\?|{\d+(?:,\d*)?}\??)/,
            // Any native multicharacter token in character class scope (includes octals)
            "class": /^(?:\\(?:[0-3][0-7]{0,2}|[4-7][0-7]?|x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|c[A-Za-z]|[\s\S]))/
        },

// Any backreference in replacement strings
        replacementToken = /\$(?:{([\w$]+)}|(\d\d?|[\s\S]))/g,

// Any character with a later instance in the string
        duplicateFlags = /([\s\S])(?=[\s\S]*\1)/g,

// Any greedy/lazy quantifier
        quantifier = /^(?:[?*+]|{\d+(?:,\d*)?})\??/,

// Check for correct `exec` handling of nonparticipating capturing groups
        compliantExecNpcg = nativ.exec.call(/()??/, "")[1] === undef,

// Check for flag y support (Firefox 3+)
        hasNativeY = RegExp.prototype.sticky !== undef,

// Used to kill infinite recursion during XRegExp construction
        isInsideConstructor = false,

// Storage for known flags, including addon flags
        registeredFlags = "gim" + (hasNativeY ? "y" : "");

/*--------------------------------------
 *  Private helper functions
 *------------------------------------*/

/**
 * Attaches XRegExp.prototype properties and named capture supporting data to a regex object.
 * @private
 * @param {RegExp} regex Regex to augment.
 * @param {Array} captureNames Array with capture names, or null.
 * @param {Boolean} [isNative] Whether the regex was created by `RegExp` rather than `XRegExp`.
 * @returns {RegExp} Augmented regex.
 */
    function augment(regex, captureNames, isNative) {
        var p;
        // Can't auto-inherit these since the XRegExp constructor returns a nonprimitive value
        for (p in self.prototype) {
            if (self.prototype.hasOwnProperty(p)) {
                regex[p] = self.prototype[p];
            }
        }
        regex.xregexp = {captureNames: captureNames, isNative: !!isNative};
        return regex;
    }

/**
 * Returns native `RegExp` flags used by a regex object.
 * @private
 * @param {RegExp} regex Regex to check.
 * @returns {String} Native flags in use.
 */
    function getNativeFlags(regex) {
        //return nativ.exec.call(/\/([a-z]*)$/i, String(regex))[1];
        return (regex.global     ? "g" : "") +
               (regex.ignoreCase ? "i" : "") +
               (regex.multiline  ? "m" : "") +
               (regex.extended   ? "x" : "") + // Proposed for ES6, included in AS3
               (regex.sticky     ? "y" : ""); // Proposed for ES6, included in Firefox 3+
    }

/**
 * Copies a regex object while preserving special properties for named capture and augmenting with
 * `XRegExp.prototype` methods. The copy has a fresh `lastIndex` property (set to zero). Allows
 * adding and removing flags while copying the regex.
 * @private
 * @param {RegExp} regex Regex to copy.
 * @param {String} [addFlags] Flags to be added while copying the regex.
 * @param {String} [removeFlags] Flags to be removed while copying the regex.
 * @returns {RegExp} Copy of the provided regex, possibly with modified flags.
 */
    function copy(regex, addFlags, removeFlags) {
        if (!self.isRegExp(regex)) {
            throw new TypeError("type RegExp expected");
        }
        var flags = nativ.replace.call(getNativeFlags(regex) + (addFlags || ""), duplicateFlags, "");
        if (removeFlags) {
            // Would need to escape `removeFlags` if this was public
            flags = nativ.replace.call(flags, new RegExp("[" + removeFlags + "]+", "g"), "");
        }
        if (regex.xregexp && !regex.xregexp.isNative) {
            // Compiling the current (rather than precompilation) source preserves the effects of nonnative source flags
            regex = augment(self(regex.source, flags),
                            regex.xregexp.captureNames ? regex.xregexp.captureNames.slice(0) : null);
        } else {
            // Augment with `XRegExp.prototype` methods, but use native `RegExp` (avoid searching for special tokens)
            regex = augment(new RegExp(regex.source, flags), null, true);
        }
        return regex;
    }

/*
 * Returns the last index at which a given value can be found in an array, or `-1` if it's not
 * present. The array is searched backwards.
 * @private
 * @param {Array} array Array to search.
 * @param {*} value Value to locate in the array.
 * @returns {Number} Last zero-based index at which the item is found, or -1.
 */
    function lastIndexOf(array, value) {
        var i = array.length;
        if (Array.prototype.lastIndexOf) {
            return array.lastIndexOf(value); // Use the native method if available
        }
        while (i--) {
            if (array[i] === value) {
                return i;
            }
        }
        return -1;
    }

/**
 * Determines whether an object is of the specified type.
 * @private
 * @param {*} value Object to check.
 * @param {String} type Type to check for, in lowercase.
 * @returns {Boolean} Whether the object matches the type.
 */
    function isType(value, type) {
        return Object.prototype.toString.call(value).toLowerCase() === "[object " + type + "]";
    }

/**
 * Prepares an options object from the given value.
 * @private
 * @param {String|Object} value Value to convert to an options object.
 * @returns {Object} Options object.
 */
    function prepareOptions(value) {
        value = value || {};
        if (value === "all" || value.all) {
            value = {natives: true, extensibility: true};
        } else if (isType(value, "string")) {
            value = self.forEach(value, /[^\s,]+/, function (m) {
                this[m] = true;
            }, {});
        }
        return value;
    }

/**
 * Runs built-in/custom tokens in reverse insertion order, until a match is found.
 * @private
 * @param {String} pattern Original pattern from which an XRegExp object is being built.
 * @param {Number} pos Position to search for tokens within `pattern`.
 * @param {Number} scope Current regex scope.
 * @param {Object} context Context object assigned to token handler functions.
 * @returns {Object} Object with properties `output` (the substitution string returned by the
 *   successful token handler) and `match` (the token's match array), or null.
 */
    function runTokens(pattern, pos, scope, context) {
        var i = tokens.length,
            result = null,
            match,
            t;
        // Protect against constructing XRegExps within token handler and trigger functions
        isInsideConstructor = true;
        // Must reset `isInsideConstructor`, even if a `trigger` or `handler` throws
        try {
            while (i--) { // Run in reverse order
                t = tokens[i];
                if ((t.scope === "all" || t.scope === scope) && (!t.trigger || t.trigger.call(context))) {
                    t.pattern.lastIndex = pos;
                    match = fixed.exec.call(t.pattern, pattern); // Fixed `exec` here allows use of named backreferences, etc.
                    if (match && match.index === pos) {
                        result = {
                            output: t.handler.call(context, match, scope),
                            match: match
                        };
                        break;
                    }
                }
            }
        } catch (err) {
            throw err;
        } finally {
            isInsideConstructor = false;
        }
        return result;
    }

/**
 * Enables or disables XRegExp syntax and flag extensibility.
 * @private
 * @param {Boolean} on `true` to enable; `false` to disable.
 */
    function setExtensibility(on) {
        self.addToken = addToken[on ? "on" : "off"];
        features.extensibility = on;
    }

/**
 * Enables or disables native method overrides.
 * @private
 * @param {Boolean} on `true` to enable; `false` to disable.
 */
    function setNatives(on) {
        RegExp.prototype.exec = (on ? fixed : nativ).exec;
        RegExp.prototype.test = (on ? fixed : nativ).test;
        String.prototype.match = (on ? fixed : nativ).match;
        String.prototype.replace = (on ? fixed : nativ).replace;
        String.prototype.split = (on ? fixed : nativ).split;
        features.natives = on;
    }

/*--------------------------------------
 *  Constructor
 *------------------------------------*/

/**
 * Creates an extended regular expression object for matching text with a pattern. Differs from a
 * native regular expression in that additional syntax and flags are supported. The returned object
 * is in fact a native `RegExp` and works with all native methods.
 * @class XRegExp
 * @constructor
 * @param {String|RegExp} pattern Regex pattern string, or an existing `RegExp` object to copy.
 * @param {String} [flags] Any combination of flags:
 *   <li>`g` - global
 *   <li>`i` - ignore case
 *   <li>`m` - multiline anchors
 *   <li>`n` - explicit capture
 *   <li>`s` - dot matches all (aka singleline)
 *   <li>`x` - free-spacing and line comments (aka extended)
 *   <li>`y` - sticky (Firefox 3+ only)
 *   Flags cannot be provided when constructing one `RegExp` from another.
 * @returns {RegExp} Extended regular expression object.
 * @example
 *
 * // With named capture and flag x
 * date = XRegExp('(?<year>  [0-9]{4}) -?  # year  \n\
 *                 (?<month> [0-9]{2}) -?  # month \n\
 *                 (?<day>   [0-9]{2})     # day   ', 'x');
 *
 * // Passing a regex object to copy it. The copy maintains special properties for named capture,
 * // is augmented with `XRegExp.prototype` methods, and has a fresh `lastIndex` property (set to
 * // zero). Native regexes are not recompiled using XRegExp syntax.
 * XRegExp(/regex/);
 */
    self = function (pattern, flags) {
        if (self.isRegExp(pattern)) {
            if (flags !== undef) {
                throw new TypeError("can't supply flags when constructing one RegExp from another");
            }
            return copy(pattern);
        }
        // Tokens become part of the regex construction process, so protect against infinite recursion
        // when an XRegExp is constructed within a token handler function
        if (isInsideConstructor) {
            throw new Error("can't call the XRegExp constructor within token definition functions");
        }

        var output = [],
            scope = defaultScope,
            tokenContext = {
                hasNamedCapture: false,
                captureNames: [],
                hasFlag: function (flag) {
                    return flags.indexOf(flag) > -1;
                }
            },
            pos = 0,
            tokenResult,
            match,
            chr;
        pattern = pattern === undef ? "" : String(pattern);
        flags = flags === undef ? "" : String(flags);

        if (nativ.match.call(flags, duplicateFlags)) { // Don't use test/exec because they would update lastIndex
            throw new SyntaxError("invalid duplicate regular expression flag");
        }
        // Strip/apply leading mode modifier with any combination of flags except g or y: (?imnsx)
        pattern = nativ.replace.call(pattern, /^\(\?([\w$]+)\)/, function ($0, $1) {
            if (nativ.test.call(/[gy]/, $1)) {
                throw new SyntaxError("can't use flag g or y in mode modifier");
            }
            flags = nativ.replace.call(flags + $1, duplicateFlags, "");
            return "";
        });
        self.forEach(flags, /[\s\S]/, function (m) {
            if (registeredFlags.indexOf(m[0]) < 0) {
                throw new SyntaxError("invalid regular expression flag " + m[0]);
            }
        });

        while (pos < pattern.length) {
            // Check for custom tokens at the current position
            tokenResult = runTokens(pattern, pos, scope, tokenContext);
            if (tokenResult) {
                output.push(tokenResult.output);
                pos += (tokenResult.match[0].length || 1);
            } else {
                // Check for native tokens (except character classes) at the current position
                match = nativ.exec.call(nativeTokens[scope], pattern.slice(pos));
                if (match) {
                    output.push(match[0]);
                    pos += match[0].length;
                } else {
                    chr = pattern.charAt(pos);
                    if (chr === "[") {
                        scope = classScope;
                    } else if (chr === "]") {
                        scope = defaultScope;
                    }
                    // Advance position by one character
                    output.push(chr);
                    ++pos;
                }
            }
        }

        return augment(new RegExp(output.join(""), nativ.replace.call(flags, /[^gimy]+/g, "")),
                       tokenContext.hasNamedCapture ? tokenContext.captureNames : null);
    };

/*--------------------------------------
 *  Public methods/properties
 *------------------------------------*/

// Installed and uninstalled states for `XRegExp.addToken`
    addToken = {
        on: function (regex, handler, options) {
            options = options || {};
            if (regex) {
                tokens.push({
                    pattern: copy(regex, "g" + (hasNativeY ? "y" : "")),
                    handler: handler,
                    scope: options.scope || defaultScope,
                    trigger: options.trigger || null
                });
            }
            // Providing `customFlags` with null `regex` and `handler` allows adding flags that do
            // nothing, but don't throw an error
            if (options.customFlags) {
                registeredFlags = nativ.replace.call(registeredFlags + options.customFlags, duplicateFlags, "");
            }
        },
        off: function () {
            throw new Error("extensibility must be installed before using addToken");
        }
    };

/**
 * Extends or changes XRegExp syntax and allows custom flags. This is used internally and can be
 * used to create XRegExp addons. `XRegExp.install('extensibility')` must be run before calling
 * this function, or an error is thrown. If more than one token can match the same string, the last
 * added wins.
 * @memberOf XRegExp
 * @param {RegExp} regex Regex object that matches the new token.
 * @param {Function} handler Function that returns a new pattern string (using native regex syntax)
 *   to replace the matched token within all future XRegExp regexes. Has access to persistent
 *   properties of the regex being built, through `this`. Invoked with two arguments:
 *   <li>The match array, with named backreference properties.
 *   <li>The regex scope where the match was found.
 * @param {Object} [options] Options object with optional properties:
 *   <li>`scope` {String} Scopes where the token applies: 'default', 'class', or 'all'.
 *   <li>`trigger` {Function} Function that returns `true` when the token should be applied; e.g.,
 *     if a flag is set. If `false` is returned, the matched string can be matched by other tokens.
 *     Has access to persistent properties of the regex being built, through `this` (including
 *     function `this.hasFlag`).
 *   <li>`customFlags` {String} Nonnative flags used by the token's handler or trigger functions.
 *     Prevents XRegExp from throwing an invalid flag error when the specified flags are used.
 * @example
 *
 * // Basic usage: Adds \a for ALERT character
 * XRegExp.addToken(
 *   /\\a/,
 *   function () {return '\\x07';},
 *   {scope: 'all'}
 * );
 * XRegExp('\\a[\\a-\\n]+').test('\x07\n\x07'); // -> true
 */
    self.addToken = addToken.off;

/**
 * Caches and returns the result of calling `XRegExp(pattern, flags)`. On any subsequent call with
 * the same pattern and flag combination, the cached copy is returned.
 * @memberOf XRegExp
 * @param {String} pattern Regex pattern string.
 * @param {String} [flags] Any combination of XRegExp flags.
 * @returns {RegExp} Cached XRegExp object.
 * @example
 *
 * while (match = XRegExp.cache('.', 'gs').exec(str)) {
 *   // The regex is compiled once only
 * }
 */
    self.cache = function (pattern, flags) {
        var key = pattern + "/" + (flags || "");
        return cache[key] || (cache[key] = self(pattern, flags));
    };

/**
 * Escapes any regular expression metacharacters, for use when matching literal strings. The result
 * can safely be used at any point within a regex that uses any flags.
 * @memberOf XRegExp
 * @param {String} str String to escape.
 * @returns {String} String with regex metacharacters escaped.
 * @example
 *
 * XRegExp.escape('Escaped? <.>');
 * // -> 'Escaped\?\ <\.>'
 */
    self.escape = function (str) {
        return nativ.replace.call(str, /[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
    };

/**
 * Executes a regex search in a specified string. Returns a match array or `null`. If the provided
 * regex uses named capture, named backreference properties are included on the match array.
 * Optional `pos` and `sticky` arguments specify the search start position, and whether the match
 * must start at the specified position only. The `lastIndex` property of the provided regex is not
 * used, but is updated for compatibility. Also fixes browser bugs compared to the native
 * `RegExp.prototype.exec` and can be used reliably cross-browser.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {RegExp} regex Regex to search with.
 * @param {Number} [pos=0] Zero-based index at which to start the search.
 * @param {Boolean|String} [sticky=false] Whether the match must start at the specified position
 *   only. The string `'sticky'` is accepted as an alternative to `true`.
 * @returns {Array} Match array with named backreference properties, or null.
 * @example
 *
 * // Basic use, with named backreference
 * var match = XRegExp.exec('U+2620', XRegExp('U\\+(?<hex>[0-9A-F]{4})'));
 * match.hex; // -> '2620'
 *
 * // With pos and sticky, in a loop
 * var pos = 2, result = [], match;
 * while (match = XRegExp.exec('<1><2><3><4>5<6>', /<(\d)>/, pos, 'sticky')) {
 *   result.push(match[1]);
 *   pos = match.index + match[0].length;
 * }
 * // result -> ['2', '3', '4']
 */
    self.exec = function (str, regex, pos, sticky) {
        var r2 = copy(regex, "g" + (sticky && hasNativeY ? "y" : ""), (sticky === false ? "y" : "")),
            match;
        r2.lastIndex = pos = pos || 0;
        match = fixed.exec.call(r2, str); // Fixed `exec` required for `lastIndex` fix, etc.
        if (sticky && match && match.index !== pos) {
            match = null;
        }
        if (regex.global) {
            regex.lastIndex = match ? r2.lastIndex : 0;
        }
        return match;
    };

/**
 * Executes a provided function once per regex match.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {RegExp} regex Regex to search with.
 * @param {Function} callback Function to execute for each match. Invoked with four arguments:
 *   <li>The match array, with named backreference properties.
 *   <li>The zero-based match index.
 *   <li>The string being traversed.
 *   <li>The regex object being used to traverse the string.
 * @param {*} [context] Object to use as `this` when executing `callback`.
 * @returns {*} Provided `context` object.
 * @example
 *
 * // Extracts every other digit from a string
 * XRegExp.forEach('1a2345', /\d/, function (match, i) {
 *   if (i % 2) this.push(+match[0]);
 * }, []);
 * // -> [2, 4]
 */
    self.forEach = function (str, regex, callback, context) {
        var pos = 0,
            i = -1,
            match;
        while ((match = self.exec(str, regex, pos))) {
            callback.call(context, match, ++i, str, regex);
            pos = match.index + (match[0].length || 1);
        }
        return context;
    };

/**
 * Copies a regex object and adds flag `g`. The copy maintains special properties for named
 * capture, is augmented with `XRegExp.prototype` methods, and has a fresh `lastIndex` property
 * (set to zero). Native regexes are not recompiled using XRegExp syntax.
 * @memberOf XRegExp
 * @param {RegExp} regex Regex to globalize.
 * @returns {RegExp} Copy of the provided regex with flag `g` added.
 * @example
 *
 * var globalCopy = XRegExp.globalize(/regex/);
 * globalCopy.global; // -> true
 */
    self.globalize = function (regex) {
        return copy(regex, "g");
    };

/**
 * Installs optional features according to the specified options.
 * @memberOf XRegExp
 * @param {Object|String} options Options object or string.
 * @example
 *
 * // With an options object
 * XRegExp.install({
 *   // Overrides native regex methods with fixed/extended versions that support named
 *   // backreferences and fix numerous cross-browser bugs
 *   natives: true,
 *
 *   // Enables extensibility of XRegExp syntax and flags
 *   extensibility: true
 * });
 *
 * // With an options string
 * XRegExp.install('natives extensibility');
 *
 * // Using a shortcut to install all optional features
 * XRegExp.install('all');
 */
    self.install = function (options) {
        options = prepareOptions(options);
        if (!features.natives && options.natives) {
            setNatives(true);
        }
        if (!features.extensibility && options.extensibility) {
            setExtensibility(true);
        }
    };

/**
 * Checks whether an individual optional feature is installed.
 * @memberOf XRegExp
 * @param {String} feature Name of the feature to check. One of:
 *   <li>`natives`
 *   <li>`extensibility`
 * @returns {Boolean} Whether the feature is installed.
 * @example
 *
 * XRegExp.isInstalled('natives');
 */
    self.isInstalled = function (feature) {
        return !!(features[feature]);
    };

/**
 * Returns `true` if an object is a regex; `false` if it isn't. This works correctly for regexes
 * created in another frame, when `instanceof` and `constructor` checks would fail.
 * @memberOf XRegExp
 * @param {*} value Object to check.
 * @returns {Boolean} Whether the object is a `RegExp` object.
 * @example
 *
 * XRegExp.isRegExp('string'); // -> false
 * XRegExp.isRegExp(/regex/i); // -> true
 * XRegExp.isRegExp(RegExp('^', 'm')); // -> true
 * XRegExp.isRegExp(XRegExp('(?s).')); // -> true
 */
    self.isRegExp = function (value) {
        return isType(value, "regexp");
    };

/**
 * Retrieves the matches from searching a string using a chain of regexes that successively search
 * within previous matches. The provided `chain` array can contain regexes and objects with `regex`
 * and `backref` properties. When a backreference is specified, the named or numbered backreference
 * is passed forward to the next regex or returned.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {Array} chain Regexes that each search for matches within preceding results.
 * @returns {Array} Matches by the last regex in the chain, or an empty array.
 * @example
 *
 * // Basic usage; matches numbers within <b> tags
 * XRegExp.matchChain('1 <b>2</b> 3 <b>4 a 56</b>', [
 *   XRegExp('(?is)<b>.*?</b>'),
 *   /\d+/
 * ]);
 * // -> ['2', '4', '56']
 *
 * // Passing forward and returning specific backreferences
 * html = '<a href="http://xregexp.com/api/">XRegExp</a>\
 *         <a href="http://www.google.com/">Google</a>';
 * XRegExp.matchChain(html, [
 *   {regex: /<a href="([^"]+)">/i, backref: 1},
 *   {regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
 * ]);
 * // -> ['xregexp.com', 'www.google.com']
 */
    self.matchChain = function (str, chain) {
        return (function recurseChain(values, level) {
            var item = chain[level].regex ? chain[level] : {regex: chain[level]},
                matches = [],
                addMatch = function (match) {
                    matches.push(item.backref ? (match[item.backref] || "") : match[0]);
                },
                i;
            for (i = 0; i < values.length; ++i) {
                self.forEach(values[i], item.regex, addMatch);
            }
            return ((level === chain.length - 1) || !matches.length) ?
                    matches :
                    recurseChain(matches, level + 1);
        }([str], 0));
    };

/**
 * Returns a new string with one or all matches of a pattern replaced. The pattern can be a string
 * or regex, and the replacement can be a string or a function to be called for each match. To
 * perform a global search and replace, use the optional `scope` argument or include flag `g` if
 * using a regex. Replacement strings can use `${n}` for named and numbered backreferences.
 * Replacement functions can use named backreferences via `arguments[0].name`. Also fixes browser
 * bugs compared to the native `String.prototype.replace` and can be used reliably cross-browser.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {RegExp|String} search Search pattern to be replaced.
 * @param {String|Function} replacement Replacement string or a function invoked to create it.
 *   Replacement strings can include special replacement syntax:
 *     <li>$$ - Inserts a literal '$'.
 *     <li>$&, $0 - Inserts the matched substring.
 *     <li>$` - Inserts the string that precedes the matched substring (left context).
 *     <li>$' - Inserts the string that follows the matched substring (right context).
 *     <li>$n, $nn - Where n/nn are digits referencing an existent capturing group, inserts
 *       backreference n/nn.
 *     <li>${n} - Where n is a name or any number of digits that reference an existent capturing
 *       group, inserts backreference n.
 *   Replacement functions are invoked with three or more arguments:
 *     <li>The matched substring (corresponds to $& above). Named backreferences are accessible as
 *       properties of this first argument.
 *     <li>0..n arguments, one for each backreference (corresponding to $1, $2, etc. above).
 *     <li>The zero-based index of the match within the total search string.
 *     <li>The total string being searched.
 * @param {String} [scope='one'] Use 'one' to replace the first match only, or 'all'. If not
 *   explicitly specified and using a regex with flag `g`, `scope` is 'all'.
 * @returns {String} New string with one or all matches replaced.
 * @example
 *
 * // Regex search, using named backreferences in replacement string
 * var name = XRegExp('(?<first>\\w+) (?<last>\\w+)');
 * XRegExp.replace('John Smith', name, '${last}, ${first}');
 * // -> 'Smith, John'
 *
 * // Regex search, using named backreferences in replacement function
 * XRegExp.replace('John Smith', name, function (match) {
 *   return match.last + ', ' + match.first;
 * });
 * // -> 'Smith, John'
 *
 * // Global string search/replacement
 * XRegExp.replace('RegExp builds RegExps', 'RegExp', 'XRegExp', 'all');
 * // -> 'XRegExp builds XRegExps'
 */
    self.replace = function (str, search, replacement, scope) {
        var isRegex = self.isRegExp(search),
            search2 = search,
            result;
        if (isRegex) {
            if (scope === undef && search.global) {
                scope = "all"; // Follow flag g when `scope` isn't explicit
            }
            // Note that since a copy is used, `search`'s `lastIndex` isn't updated *during* replacement iterations
            search2 = copy(search, scope === "all" ? "g" : "", scope === "all" ? "" : "g");
        } else if (scope === "all") {
            search2 = new RegExp(self.escape(String(search)), "g");
        }
        result = fixed.replace.call(String(str), search2, replacement); // Fixed `replace` required for named backreferences, etc.
        if (isRegex && search.global) {
            search.lastIndex = 0; // Fixes IE, Safari bug (last tested IE 9, Safari 5.1)
        }
        return result;
    };

/**
 * Splits a string into an array of strings using a regex or string separator. Matches of the
 * separator are not included in the result array. However, if `separator` is a regex that contains
 * capturing groups, backreferences are spliced into the result each time `separator` is matched.
 * Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably
 * cross-browser.
 * @memberOf XRegExp
 * @param {String} str String to split.
 * @param {RegExp|String} separator Regex or string to use for separating the string.
 * @param {Number} [limit] Maximum number of items to include in the result array.
 * @returns {Array} Array of substrings.
 * @example
 *
 * // Basic use
 * XRegExp.split('a b c', ' ');
 * // -> ['a', 'b', 'c']
 *
 * // With limit
 * XRegExp.split('a b c', ' ', 2);
 * // -> ['a', 'b']
 *
 * // Backreferences in result array
 * XRegExp.split('..word1..', /([a-z]+)(\d+)/i);
 * // -> ['..', 'word', '1', '..']
 */
    self.split = function (str, separator, limit) {
        return fixed.split.call(str, separator, limit);
    };

/**
 * Executes a regex search in a specified string. Returns `true` or `false`. Optional `pos` and
 * `sticky` arguments specify the search start position, and whether the match must start at the
 * specified position only. The `lastIndex` property of the provided regex is not used, but is
 * updated for compatibility. Also fixes browser bugs compared to the native
 * `RegExp.prototype.test` and can be used reliably cross-browser.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {RegExp} regex Regex to search with.
 * @param {Number} [pos=0] Zero-based index at which to start the search.
 * @param {Boolean|String} [sticky=false] Whether the match must start at the specified position
 *   only. The string `'sticky'` is accepted as an alternative to `true`.
 * @returns {Boolean} Whether the regex matched the provided value.
 * @example
 *
 * // Basic use
 * XRegExp.test('abc', /c/); // -> true
 *
 * // With pos and sticky
 * XRegExp.test('abc', /c/, 0, 'sticky'); // -> false
 */
    self.test = function (str, regex, pos, sticky) {
        // Do this the easy way :-)
        return !!self.exec(str, regex, pos, sticky);
    };

/**
 * Uninstalls optional features according to the specified options.
 * @memberOf XRegExp
 * @param {Object|String} options Options object or string.
 * @example
 *
 * // With an options object
 * XRegExp.uninstall({
 *   // Restores native regex methods
 *   natives: true,
 *
 *   // Disables additional syntax and flag extensions
 *   extensibility: true
 * });
 *
 * // With an options string
 * XRegExp.uninstall('natives extensibility');
 *
 * // Using a shortcut to uninstall all optional features
 * XRegExp.uninstall('all');
 */
    self.uninstall = function (options) {
        options = prepareOptions(options);
        if (features.natives && options.natives) {
            setNatives(false);
        }
        if (features.extensibility && options.extensibility) {
            setExtensibility(false);
        }
    };

/**
 * Returns an XRegExp object that is the union of the given patterns. Patterns can be provided as
 * regex objects or strings. Metacharacters are escaped in patterns provided as strings.
 * Backreferences in provided regex objects are automatically renumbered to work correctly. Native
 * flags used by provided regexes are ignored in favor of the `flags` argument.
 * @memberOf XRegExp
 * @param {Array} patterns Regexes and strings to combine.
 * @param {String} [flags] Any combination of XRegExp flags.
 * @returns {RegExp} Union of the provided regexes and strings.
 * @example
 *
 * XRegExp.union(['a+b*c', /(dogs)\1/, /(cats)\1/], 'i');
 * // -> /a\+b\*c|(dogs)\1|(cats)\2/i
 *
 * XRegExp.union([XRegExp('(?<pet>dogs)\\k<pet>'), XRegExp('(?<pet>cats)\\k<pet>')]);
 * // -> XRegExp('(?<pet>dogs)\\k<pet>|(?<pet>cats)\\k<pet>')
 */
    self.union = function (patterns, flags) {
        var parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g,
            numCaptures = 0,
            numPriorCaptures,
            captureNames,
            rewrite = function (match, paren, backref) {
                var name = captureNames[numCaptures - numPriorCaptures];
                if (paren) { // Capturing group
                    ++numCaptures;
                    if (name) { // If the current capture has a name
                        return "(?<" + name + ">";
                    }
                } else if (backref) { // Backreference
                    return "\\" + (+backref + numPriorCaptures);
                }
                return match;
            },
            output = [],
            pattern,
            i;
        if (!(isType(patterns, "array") && patterns.length)) {
            throw new TypeError("patterns must be a nonempty array");
        }
        for (i = 0; i < patterns.length; ++i) {
            pattern = patterns[i];
            if (self.isRegExp(pattern)) {
                numPriorCaptures = numCaptures;
                captureNames = (pattern.xregexp && pattern.xregexp.captureNames) || [];
                // Rewrite backreferences. Passing to XRegExp dies on octals and ensures patterns
                // are independently valid; helps keep this simple. Named captures are put back
                output.push(self(pattern.source).source.replace(parts, rewrite));
            } else {
                output.push(self.escape(pattern));
            }
        }
        return self(output.join("|"), flags);
    };

/**
 * The XRegExp version number.
 * @static
 * @memberOf XRegExp
 * @type String
 */
    self.version = "2.0.0";

/*--------------------------------------
 *  Fixed/extended native methods
 *------------------------------------*/

/**
 * Adds named capture support (with backreferences returned as `result.name`), and fixes browser
 * bugs in the native `RegExp.prototype.exec`. Calling `XRegExp.install('natives')` uses this to
 * override the native method. Use via `XRegExp.exec` without overriding natives.
 * @private
 * @param {String} str String to search.
 * @returns {Array} Match array with named backreference properties, or null.
 */
    fixed.exec = function (str) {
        var match, name, r2, origLastIndex, i;
        if (!this.global) {
            origLastIndex = this.lastIndex;
        }
        match = nativ.exec.apply(this, arguments);
        if (match) {
            // Fix browsers whose `exec` methods don't consistently return `undefined` for
            // nonparticipating capturing groups
            if (!compliantExecNpcg && match.length > 1 && lastIndexOf(match, "") > -1) {
                r2 = new RegExp(this.source, nativ.replace.call(getNativeFlags(this), "g", ""));
                // Using `str.slice(match.index)` rather than `match[0]` in case lookahead allowed
                // matching due to characters outside the match
                nativ.replace.call(String(str).slice(match.index), r2, function () {
                    var i;
                    for (i = 1; i < arguments.length - 2; ++i) {
                        if (arguments[i] === undef) {
                            match[i] = undef;
                        }
                    }
                });
            }
            // Attach named capture properties
            if (this.xregexp && this.xregexp.captureNames) {
                for (i = 1; i < match.length; ++i) {
                    name = this.xregexp.captureNames[i - 1];
                    if (name) {
                        match[name] = match[i];
                    }
                }
            }
            // Fix browsers that increment `lastIndex` after zero-length matches
            if (this.global && !match[0].length && (this.lastIndex > match.index)) {
                this.lastIndex = match.index;
            }
        }
        if (!this.global) {
            this.lastIndex = origLastIndex; // Fixes IE, Opera bug (last tested IE 9, Opera 11.6)
        }
        return match;
    };

/**
 * Fixes browser bugs in the native `RegExp.prototype.test`. Calling `XRegExp.install('natives')`
 * uses this to override the native method.
 * @private
 * @param {String} str String to search.
 * @returns {Boolean} Whether the regex matched the provided value.
 */
    fixed.test = function (str) {
        // Do this the easy way :-)
        return !!fixed.exec.call(this, str);
    };

/**
 * Adds named capture support (with backreferences returned as `result.name`), and fixes browser
 * bugs in the native `String.prototype.match`. Calling `XRegExp.install('natives')` uses this to
 * override the native method.
 * @private
 * @param {RegExp} regex Regex to search with.
 * @returns {Array} If `regex` uses flag g, an array of match strings or null. Without flag g, the
 *   result of calling `regex.exec(this)`.
 */
    fixed.match = function (regex) {
        if (!self.isRegExp(regex)) {
            regex = new RegExp(regex); // Use native `RegExp`
        } else if (regex.global) {
            var result = nativ.match.apply(this, arguments);
            regex.lastIndex = 0; // Fixes IE bug
            return result;
        }
        return fixed.exec.call(regex, this);
    };

/**
 * Adds support for `${n}` tokens for named and numbered backreferences in replacement text, and
 * provides named backreferences to replacement functions as `arguments[0].name`. Also fixes
 * browser bugs in replacement text syntax when performing a replacement using a nonregex search
 * value, and the value of a replacement regex's `lastIndex` property during replacement iterations
 * and upon completion. Note that this doesn't support SpiderMonkey's proprietary third (`flags`)
 * argument. Calling `XRegExp.install('natives')` uses this to override the native method. Use via
 * `XRegExp.replace` without overriding natives.
 * @private
 * @param {RegExp|String} search Search pattern to be replaced.
 * @param {String|Function} replacement Replacement string or a function invoked to create it.
 * @returns {String} New string with one or all matches replaced.
 */
    fixed.replace = function (search, replacement) {
        var isRegex = self.isRegExp(search), captureNames, result, str, origLastIndex;
        if (isRegex) {
            if (search.xregexp) {
                captureNames = search.xregexp.captureNames;
            }
            if (!search.global) {
                origLastIndex = search.lastIndex;
            }
        } else {
            search += "";
        }
        if (isType(replacement, "function")) {
            result = nativ.replace.call(String(this), search, function () {
                var args = arguments, i;
                if (captureNames) {
                    // Change the `arguments[0]` string primitive to a `String` object that can store properties
                    args[0] = new String(args[0]);
                    // Store named backreferences on the first argument
                    for (i = 0; i < captureNames.length; ++i) {
                        if (captureNames[i]) {
                            args[0][captureNames[i]] = args[i + 1];
                        }
                    }
                }
                // Update `lastIndex` before calling `replacement`.
                // Fixes IE, Chrome, Firefox, Safari bug (last tested IE 9, Chrome 17, Firefox 11, Safari 5.1)
                if (isRegex && search.global) {
                    search.lastIndex = args[args.length - 2] + args[0].length;
                }
                return replacement.apply(null, args);
            });
        } else {
            str = String(this); // Ensure `args[args.length - 1]` will be a string when given nonstring `this`
            result = nativ.replace.call(str, search, function () {
                var args = arguments; // Keep this function's `arguments` available through closure
                return nativ.replace.call(String(replacement), replacementToken, function ($0, $1, $2) {
                    var n;
                    // Named or numbered backreference with curly brackets
                    if ($1) {
                        /* XRegExp behavior for `${n}`:
                         * 1. Backreference to numbered capture, where `n` is 1+ digits. `0`, `00`, etc. is the entire match.
                         * 2. Backreference to named capture `n`, if it exists and is not a number overridden by numbered capture.
                         * 3. Otherwise, it's an error.
                         */
                        n = +$1; // Type-convert; drop leading zeros
                        if (n <= args.length - 3) {
                            return args[n] || "";
                        }
                        n = captureNames ? lastIndexOf(captureNames, $1) : -1;
                        if (n < 0) {
                            throw new SyntaxError("backreference to undefined group " + $0);
                        }
                        return args[n + 1] || "";
                    }
                    // Else, special variable or numbered backreference (without curly brackets)
                    if ($2 === "$") return "$";
                    if ($2 === "&" || +$2 === 0) return args[0]; // $&, $0 (not followed by 1-9), $00
                    if ($2 === "`") return args[args.length - 1].slice(0, args[args.length - 2]);
                    if ($2 === "'") return args[args.length - 1].slice(args[args.length - 2] + args[0].length);
                    // Else, numbered backreference (without curly brackets)
                    $2 = +$2; // Type-convert; drop leading zero
                    /* XRegExp behavior:
                     * - Backreferences without curly brackets end after 1 or 2 digits. Use `${..}` for more digits.
                     * - `$1` is an error if there are no capturing groups.
                     * - `$10` is an error if there are less than 10 capturing groups. Use `${1}0` instead.
                     * - `$01` is equivalent to `$1` if a capturing group exists, otherwise it's an error.
                     * - `$0` (not followed by 1-9), `$00`, and `$&` are the entire match.
                     * Native behavior, for comparison:
                     * - Backreferences end after 1 or 2 digits. Cannot use backreference to capturing group 100+.
                     * - `$1` is a literal `$1` if there are no capturing groups.
                     * - `$10` is `$1` followed by a literal `0` if there are less than 10 capturing groups.
                     * - `$01` is equivalent to `$1` if a capturing group exists, otherwise it's a literal `$01`.
                     * - `$0` is a literal `$0`. `$&` is the entire match.
                     */
                    if (!isNaN($2)) {
                        if ($2 > args.length - 3) {
                            throw new SyntaxError("backreference to undefined group " + $0);
                        }
                        return args[$2] || "";
                    }
                    throw new SyntaxError("invalid token " + $0);
                });
            });
        }
        if (isRegex) {
            if (search.global) {
                search.lastIndex = 0; // Fixes IE, Safari bug (last tested IE 9, Safari 5.1)
            } else {
                search.lastIndex = origLastIndex; // Fixes IE, Opera bug (last tested IE 9, Opera 11.6)
            }
        }
        return result;
    };

/**
 * Fixes browser bugs in the native `String.prototype.split`. Calling `XRegExp.install('natives')`
 * uses this to override the native method. Use via `XRegExp.split` without overriding natives.
 * @private
 * @param {RegExp|String} separator Regex or string to use for separating the string.
 * @param {Number} [limit] Maximum number of items to include in the result array.
 * @returns {Array} Array of substrings.
 */
    fixed.split = function (separator, limit) {
        if (!self.isRegExp(separator)) {
            return nativ.split.apply(this, arguments); // use faster native method
        }
        var str = String(this),
            origLastIndex = separator.lastIndex,
            output = [],
            lastLastIndex = 0,
            lastLength;
        /* Values for `limit`, per the spec:
         * If undefined: pow(2,32) - 1
         * If 0, Infinity, or NaN: 0
         * If positive number: limit = floor(limit); if (limit >= pow(2,32)) limit -= pow(2,32);
         * If negative number: pow(2,32) - floor(abs(limit))
         * If other: Type-convert, then use the above rules
         */
        limit = (limit === undef ? -1 : limit) >>> 0;
        self.forEach(str, separator, function (match) {
            if ((match.index + match[0].length) > lastLastIndex) { // != `if (match[0].length)`
                output.push(str.slice(lastLastIndex, match.index));
                if (match.length > 1 && match.index < str.length) {
                    Array.prototype.push.apply(output, match.slice(1));
                }
                lastLength = match[0].length;
                lastLastIndex = match.index + lastLength;
            }
        });
        if (lastLastIndex === str.length) {
            if (!nativ.test.call(separator, "") || lastLength) {
                output.push("");
            }
        } else {
            output.push(str.slice(lastLastIndex));
        }
        separator.lastIndex = origLastIndex;
        return output.length > limit ? output.slice(0, limit) : output;
    };

/*--------------------------------------
 *  Built-in tokens
 *------------------------------------*/

// Shortcut
    add = addToken.on;

/* Letter identity escapes that natively match literal characters: \p, \P, etc.
 * Should be SyntaxErrors but are allowed in web reality. XRegExp makes them errors for cross-
 * browser consistency and to reserve their syntax, but lets them be superseded by XRegExp addons.
 */
    add(/\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4})|x(?![\dA-Fa-f]{2}))/,
        function (match, scope) {
            // \B is allowed in default scope only
            if (match[1] === "B" && scope === defaultScope) {
                return match[0];
            }
            throw new SyntaxError("invalid escape " + match[0]);
        },
        {scope: "all"});

/* Empty character class: [] or [^]
 * Fixes a critical cross-browser syntax inconsistency. Unless this is standardized (per the spec),
 * regex syntax can't be accurately parsed because character class endings can't be determined.
 */
    add(/\[(\^?)]/,
        function (match) {
            // For cross-browser compatibility with ES3, convert [] to \b\B and [^] to [\s\S].
            // (?!) should work like \b\B, but is unreliable in Firefox
            return match[1] ? "[\\s\\S]" : "\\b\\B";
        });

/* Comment pattern: (?# )
 * Inline comments are an alternative to the line comments allowed in free-spacing mode (flag x).
 */
    add(/(?:\(\?#[^)]*\))+/,
        function (match) {
            // Keep tokens separated unless the following token is a quantifier
            return nativ.test.call(quantifier, match.input.slice(match.index + match[0].length)) ? "" : "(?:)";
        });

/* Named backreference: \k<name>
 * Backreference names can use the characters A-Z, a-z, 0-9, _, and $ only.
 */
    add(/\\k<([\w$]+)>/,
        function (match) {
            var index = isNaN(match[1]) ? (lastIndexOf(this.captureNames, match[1]) + 1) : +match[1],
                endIndex = match.index + match[0].length;
            if (!index || index > this.captureNames.length) {
                throw new SyntaxError("backreference to undefined group " + match[0]);
            }
            // Keep backreferences separate from subsequent literal numbers
            return "\\" + index + (
                endIndex === match.input.length || isNaN(match.input.charAt(endIndex)) ? "" : "(?:)"
            );
        });

/* Whitespace and line comments, in free-spacing mode (aka extended mode, flag x) only.
 */
    add(/(?:\s+|#.*)+/,
        function (match) {
            // Keep tokens separated unless the following token is a quantifier
            return nativ.test.call(quantifier, match.input.slice(match.index + match[0].length)) ? "" : "(?:)";
        },
        {
            trigger: function () {
                return this.hasFlag("x");
            },
            customFlags: "x"
        });

/* Dot, in dotall mode (aka singleline mode, flag s) only.
 */
    add(/\./,
        function () {
            return "[\\s\\S]";
        },
        {
            trigger: function () {
                return this.hasFlag("s");
            },
            customFlags: "s"
        });

/* Named capturing group; match the opening delimiter only: (?<name>
 * Capture names can use the characters A-Z, a-z, 0-9, _, and $ only. Names can't be integers.
 * Supports Python-style (?P<name> as an alternate syntax to avoid issues in recent Opera (which
 * natively supports the Python-style syntax). Otherwise, XRegExp might treat numbered
 * backreferences to Python-style named capture as octals.
 */
    add(/\(\?P?<([\w$]+)>/,
        function (match) {
            if (!isNaN(match[1])) {
                // Avoid incorrect lookups, since named backreferences are added to match arrays
                throw new SyntaxError("can't use integer as capture name " + match[0]);
            }
            this.captureNames.push(match[1]);
            this.hasNamedCapture = true;
            return "(";
        });

/* Numbered backreference or octal, plus any following digits: \0, \11, etc.
 * Octals except \0 not followed by 0-9 and backreferences to unopened capture groups throw an
 * error. Other matches are returned unaltered. IE <= 8 doesn't support backreferences greater than
 * \99 in regex syntax.
 */
    add(/\\(\d+)/,
        function (match, scope) {
            if (!(scope === defaultScope && /^[1-9]/.test(match[1]) && +match[1] <= this.captureNames.length) &&
                    match[1] !== "0") {
                throw new SyntaxError("can't use octal escape or backreference to undefined group " + match[0]);
            }
            return match[0];
        },
        {scope: "all"});

/* Capturing group; match the opening parenthesis only.
 * Required for support of named capturing groups. Also adds explicit capture mode (flag n).
 */
    add(/\((?!\?)/,
        function () {
            if (this.hasFlag("n")) {
                return "(?:";
            }
            this.captureNames.push(null);
            return "(";
        },
        {customFlags: "n"});

/*--------------------------------------
 *  Expose XRegExp
 *------------------------------------*/

// For CommonJS enviroments
    if (typeof exports !== "undefined") {
        exports.XRegExp = self;
    }

    return self;

}());


/***** unicode-base.js *****/

/*!
 * XRegExp Unicode Base v1.0.0
 * (c) 2008-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds support for the `\p{L}` or `\p{Letter}` Unicode category. Addon packages for other Unicode
 * categories, scripts, blocks, and properties are available separately. All Unicode tokens can be
 * inverted using `\P{..}` or `\p{^..}`. Token names are case insensitive, and any spaces, hyphens,
 * and underscores are ignored.
 * @requires XRegExp
 */
(function (XRegExp) {
    "use strict";

    var unicode = {};

/*--------------------------------------
 *  Private helper functions
 *------------------------------------*/

// Generates a standardized token name (lowercase, with hyphens, spaces, and underscores removed)
    function slug(name) {
        return name.replace(/[- _]+/g, "").toLowerCase();
    }

// Expands a list of Unicode code points and ranges to be usable in a regex character class
    function expand(str) {
        return str.replace(/\w{4}/g, "\\u$&");
    }

// Adds leading zeros if shorter than four characters
    function pad4(str) {
        while (str.length < 4) {
            str = "0" + str;
        }
        return str;
    }

// Converts a hexadecimal number to decimal
    function dec(hex) {
        return parseInt(hex, 16);
    }

// Converts a decimal number to hexadecimal
    function hex(dec) {
        return parseInt(dec, 10).toString(16);
    }

// Inverts a list of Unicode code points and ranges
    function invert(range) {
        var output = [],
            lastEnd = -1,
            start;
        XRegExp.forEach(range, /\\u(\w{4})(?:-\\u(\w{4}))?/, function (m) {
            start = dec(m[1]);
            if (start > (lastEnd + 1)) {
                output.push("\\u" + pad4(hex(lastEnd + 1)));
                if (start > (lastEnd + 2)) {
                    output.push("-\\u" + pad4(hex(start - 1)));
                }
            }
            lastEnd = dec(m[2] || m[1]);
        });
        if (lastEnd < 0xFFFF) {
            output.push("\\u" + pad4(hex(lastEnd + 1)));
            if (lastEnd < 0xFFFE) {
                output.push("-\\uFFFF");
            }
        }
        return output.join("");
    }

// Generates an inverted token on first use
    function cacheInversion(item) {
        return unicode["^" + item] || (unicode["^" + item] = invert(unicode[item]));
    }

/*--------------------------------------
 *  Core functionality
 *------------------------------------*/

    XRegExp.install("extensibility");

/**
 * Adds to the list of Unicode properties that XRegExp regexes can match via \p{..} or \P{..}.
 * @memberOf XRegExp
 * @param {Object} pack Named sets of Unicode code points and ranges.
 * @param {Object} [aliases] Aliases for the primary token names.
 * @example
 *
 * XRegExp.addUnicodePackage({
 *   XDigit: '0030-00390041-00460061-0066' // 0-9A-Fa-f
 * }, {
 *   XDigit: 'Hexadecimal'
 * });
 */
    XRegExp.addUnicodePackage = function (pack, aliases) {
        var p;
        if (!XRegExp.isInstalled("extensibility")) {
            throw new Error("extensibility must be installed before adding Unicode packages");
        }
        if (pack) {
            for (p in pack) {
                if (pack.hasOwnProperty(p)) {
                    unicode[slug(p)] = expand(pack[p]);
                }
            }
        }
        if (aliases) {
            for (p in aliases) {
                if (aliases.hasOwnProperty(p)) {
                    unicode[slug(aliases[p])] = unicode[slug(p)];
                }
            }
        }
    };

/* Adds data for the Unicode `Letter` category. Addon packages include other categories, scripts,
 * blocks, and properties.
 */
    XRegExp.addUnicodePackage({
        L: "0041-005A0061-007A00AA00B500BA00C0-00D600D8-00F600F8-02C102C6-02D102E0-02E402EC02EE0370-037403760377037A-037D03860388-038A038C038E-03A103A3-03F503F7-0481048A-05270531-055605590561-058705D0-05EA05F0-05F20620-064A066E066F0671-06D306D506E506E606EE06EF06FA-06FC06FF07100712-072F074D-07A507B107CA-07EA07F407F507FA0800-0815081A082408280840-085808A008A2-08AC0904-0939093D09500958-09610971-09770979-097F0985-098C098F09900993-09A809AA-09B009B209B6-09B909BD09CE09DC09DD09DF-09E109F009F10A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A59-0A5C0A5E0A72-0A740A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABD0AD00AE00AE10B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3D0B5C0B5D0B5F-0B610B710B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BD00C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D0C580C590C600C610C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBD0CDE0CE00CE10CF10CF20D05-0D0C0D0E-0D100D12-0D3A0D3D0D4E0D600D610D7A-0D7F0D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60E01-0E300E320E330E40-0E460E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB00EB20EB30EBD0EC0-0EC40EC60EDC-0EDF0F000F40-0F470F49-0F6C0F88-0F8C1000-102A103F1050-1055105A-105D106110651066106E-10701075-1081108E10A0-10C510C710CD10D0-10FA10FC-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A1380-138F13A0-13F41401-166C166F-167F1681-169A16A0-16EA1700-170C170E-17111720-17311740-17511760-176C176E-17701780-17B317D717DC1820-18771880-18A818AA18B0-18F51900-191C1950-196D1970-19741980-19AB19C1-19C71A00-1A161A20-1A541AA71B05-1B331B45-1B4B1B83-1BA01BAE1BAF1BBA-1BE51C00-1C231C4D-1C4F1C5A-1C7D1CE9-1CEC1CEE-1CF11CF51CF61D00-1DBF1E00-1F151F18-1F1D1F20-1F451F48-1F4D1F50-1F571F591F5B1F5D1F5F-1F7D1F80-1FB41FB6-1FBC1FBE1FC2-1FC41FC6-1FCC1FD0-1FD31FD6-1FDB1FE0-1FEC1FF2-1FF41FF6-1FFC2071207F2090-209C21022107210A-211321152119-211D212421262128212A-212D212F-2139213C-213F2145-2149214E218321842C00-2C2E2C30-2C5E2C60-2CE42CEB-2CEE2CF22CF32D00-2D252D272D2D2D30-2D672D6F2D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE2E2F300530063031-3035303B303C3041-3096309D-309F30A1-30FA30FC-30FF3105-312D3131-318E31A0-31BA31F0-31FF3400-4DB54E00-9FCCA000-A48CA4D0-A4FDA500-A60CA610-A61FA62AA62BA640-A66EA67F-A697A6A0-A6E5A717-A71FA722-A788A78B-A78EA790-A793A7A0-A7AAA7F8-A801A803-A805A807-A80AA80C-A822A840-A873A882-A8B3A8F2-A8F7A8FBA90A-A925A930-A946A960-A97CA984-A9B2A9CFAA00-AA28AA40-AA42AA44-AA4BAA60-AA76AA7AAA80-AAAFAAB1AAB5AAB6AAB9-AABDAAC0AAC2AADB-AADDAAE0-AAEAAAF2-AAF4AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABE2AC00-D7A3D7B0-D7C6D7CB-D7FBF900-FA6DFA70-FAD9FB00-FB06FB13-FB17FB1DFB1F-FB28FB2A-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBB1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFBFE70-FE74FE76-FEFCFF21-FF3AFF41-FF5AFF66-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC"
    }, {
        L: "Letter"
    });

/* Adds Unicode property syntax to XRegExp: \p{..}, \P{..}, \p{^..}
 */
    XRegExp.addToken(
        /\\([pP]){(\^?)([^}]*)}/,
        function (match, scope) {
            var inv = (match[1] === "P" || match[2]) ? "^" : "",
                item = slug(match[3]);
            // The double negative \P{^..} is invalid
            if (match[1] === "P" && match[2]) {
                throw new SyntaxError("invalid double negation \\P{^");
            }
            if (!unicode.hasOwnProperty(item)) {
                throw new SyntaxError("invalid or unknown Unicode property " + match[0]);
            }
            return scope === "class" ?
                    (inv ? cacheInversion(item) : unicode[item]) :
                    "[" + inv + unicode[item] + "]";
        },
        {scope: "all"}
    );

}(XRegExp));


/***** unicode-categories.js *****/

/*!
 * XRegExp Unicode Categories v1.2.0
 * (c) 2010-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds support for all Unicode categories (aka properties) E.g., `\p{Lu}` or
 * `\p{Uppercase Letter}`. Token names are case insensitive, and any spaces, hyphens, and
 * underscores are ignored.
 * @requires XRegExp, XRegExp Unicode Base
 */
(function (XRegExp) {
    "use strict";

    if (!XRegExp.addUnicodePackage) {
        throw new ReferenceError("Unicode Base must be loaded before Unicode Categories");
    }

    XRegExp.install("extensibility");

    XRegExp.addUnicodePackage({
        //L: "", // Included in the Unicode Base addon
        Ll: "0061-007A00B500DF-00F600F8-00FF01010103010501070109010B010D010F01110113011501170119011B011D011F01210123012501270129012B012D012F01310133013501370138013A013C013E014001420144014601480149014B014D014F01510153015501570159015B015D015F01610163016501670169016B016D016F0171017301750177017A017C017E-0180018301850188018C018D019201950199-019B019E01A101A301A501A801AA01AB01AD01B001B401B601B901BA01BD-01BF01C601C901CC01CE01D001D201D401D601D801DA01DC01DD01DF01E101E301E501E701E901EB01ED01EF01F001F301F501F901FB01FD01FF02010203020502070209020B020D020F02110213021502170219021B021D021F02210223022502270229022B022D022F02310233-0239023C023F0240024202470249024B024D024F-02930295-02AF037103730377037B-037D039003AC-03CE03D003D103D5-03D703D903DB03DD03DF03E103E303E503E703E903EB03ED03EF-03F303F503F803FB03FC0430-045F04610463046504670469046B046D046F04710473047504770479047B047D047F0481048B048D048F04910493049504970499049B049D049F04A104A304A504A704A904AB04AD04AF04B104B304B504B704B904BB04BD04BF04C204C404C604C804CA04CC04CE04CF04D104D304D504D704D904DB04DD04DF04E104E304E504E704E904EB04ED04EF04F104F304F504F704F904FB04FD04FF05010503050505070509050B050D050F05110513051505170519051B051D051F05210523052505270561-05871D00-1D2B1D6B-1D771D79-1D9A1E011E031E051E071E091E0B1E0D1E0F1E111E131E151E171E191E1B1E1D1E1F1E211E231E251E271E291E2B1E2D1E2F1E311E331E351E371E391E3B1E3D1E3F1E411E431E451E471E491E4B1E4D1E4F1E511E531E551E571E591E5B1E5D1E5F1E611E631E651E671E691E6B1E6D1E6F1E711E731E751E771E791E7B1E7D1E7F1E811E831E851E871E891E8B1E8D1E8F1E911E931E95-1E9D1E9F1EA11EA31EA51EA71EA91EAB1EAD1EAF1EB11EB31EB51EB71EB91EBB1EBD1EBF1EC11EC31EC51EC71EC91ECB1ECD1ECF1ED11ED31ED51ED71ED91EDB1EDD1EDF1EE11EE31EE51EE71EE91EEB1EED1EEF1EF11EF31EF51EF71EF91EFB1EFD1EFF-1F071F10-1F151F20-1F271F30-1F371F40-1F451F50-1F571F60-1F671F70-1F7D1F80-1F871F90-1F971FA0-1FA71FB0-1FB41FB61FB71FBE1FC2-1FC41FC61FC71FD0-1FD31FD61FD71FE0-1FE71FF2-1FF41FF61FF7210A210E210F2113212F21342139213C213D2146-2149214E21842C30-2C5E2C612C652C662C682C6A2C6C2C712C732C742C76-2C7B2C812C832C852C872C892C8B2C8D2C8F2C912C932C952C972C992C9B2C9D2C9F2CA12CA32CA52CA72CA92CAB2CAD2CAF2CB12CB32CB52CB72CB92CBB2CBD2CBF2CC12CC32CC52CC72CC92CCB2CCD2CCF2CD12CD32CD52CD72CD92CDB2CDD2CDF2CE12CE32CE42CEC2CEE2CF32D00-2D252D272D2DA641A643A645A647A649A64BA64DA64FA651A653A655A657A659A65BA65DA65FA661A663A665A667A669A66BA66DA681A683A685A687A689A68BA68DA68FA691A693A695A697A723A725A727A729A72BA72DA72F-A731A733A735A737A739A73BA73DA73FA741A743A745A747A749A74BA74DA74FA751A753A755A757A759A75BA75DA75FA761A763A765A767A769A76BA76DA76FA771-A778A77AA77CA77FA781A783A785A787A78CA78EA791A793A7A1A7A3A7A5A7A7A7A9A7FAFB00-FB06FB13-FB17FF41-FF5A",
        Lu: "0041-005A00C0-00D600D8-00DE01000102010401060108010A010C010E01100112011401160118011A011C011E01200122012401260128012A012C012E01300132013401360139013B013D013F0141014301450147014A014C014E01500152015401560158015A015C015E01600162016401660168016A016C016E017001720174017601780179017B017D018101820184018601870189-018B018E-0191019301940196-0198019C019D019F01A001A201A401A601A701A901AC01AE01AF01B1-01B301B501B701B801BC01C401C701CA01CD01CF01D101D301D501D701D901DB01DE01E001E201E401E601E801EA01EC01EE01F101F401F6-01F801FA01FC01FE02000202020402060208020A020C020E02100212021402160218021A021C021E02200222022402260228022A022C022E02300232023A023B023D023E02410243-02460248024A024C024E03700372037603860388-038A038C038E038F0391-03A103A3-03AB03CF03D2-03D403D803DA03DC03DE03E003E203E403E603E803EA03EC03EE03F403F703F903FA03FD-042F04600462046404660468046A046C046E04700472047404760478047A047C047E0480048A048C048E04900492049404960498049A049C049E04A004A204A404A604A804AA04AC04AE04B004B204B404B604B804BA04BC04BE04C004C104C304C504C704C904CB04CD04D004D204D404D604D804DA04DC04DE04E004E204E404E604E804EA04EC04EE04F004F204F404F604F804FA04FC04FE05000502050405060508050A050C050E05100512051405160518051A051C051E05200522052405260531-055610A0-10C510C710CD1E001E021E041E061E081E0A1E0C1E0E1E101E121E141E161E181E1A1E1C1E1E1E201E221E241E261E281E2A1E2C1E2E1E301E321E341E361E381E3A1E3C1E3E1E401E421E441E461E481E4A1E4C1E4E1E501E521E541E561E581E5A1E5C1E5E1E601E621E641E661E681E6A1E6C1E6E1E701E721E741E761E781E7A1E7C1E7E1E801E821E841E861E881E8A1E8C1E8E1E901E921E941E9E1EA01EA21EA41EA61EA81EAA1EAC1EAE1EB01EB21EB41EB61EB81EBA1EBC1EBE1EC01EC21EC41EC61EC81ECA1ECC1ECE1ED01ED21ED41ED61ED81EDA1EDC1EDE1EE01EE21EE41EE61EE81EEA1EEC1EEE1EF01EF21EF41EF61EF81EFA1EFC1EFE1F08-1F0F1F18-1F1D1F28-1F2F1F38-1F3F1F48-1F4D1F591F5B1F5D1F5F1F68-1F6F1FB8-1FBB1FC8-1FCB1FD8-1FDB1FE8-1FEC1FF8-1FFB21022107210B-210D2110-211221152119-211D212421262128212A-212D2130-2133213E213F214521832C00-2C2E2C602C62-2C642C672C692C6B2C6D-2C702C722C752C7E-2C802C822C842C862C882C8A2C8C2C8E2C902C922C942C962C982C9A2C9C2C9E2CA02CA22CA42CA62CA82CAA2CAC2CAE2CB02CB22CB42CB62CB82CBA2CBC2CBE2CC02CC22CC42CC62CC82CCA2CCC2CCE2CD02CD22CD42CD62CD82CDA2CDC2CDE2CE02CE22CEB2CED2CF2A640A642A644A646A648A64AA64CA64EA650A652A654A656A658A65AA65CA65EA660A662A664A666A668A66AA66CA680A682A684A686A688A68AA68CA68EA690A692A694A696A722A724A726A728A72AA72CA72EA732A734A736A738A73AA73CA73EA740A742A744A746A748A74AA74CA74EA750A752A754A756A758A75AA75CA75EA760A762A764A766A768A76AA76CA76EA779A77BA77DA77EA780A782A784A786A78BA78DA790A792A7A0A7A2A7A4A7A6A7A8A7AAFF21-FF3A",
        Lt: "01C501C801CB01F21F88-1F8F1F98-1F9F1FA8-1FAF1FBC1FCC1FFC",
        Lm: "02B0-02C102C6-02D102E0-02E402EC02EE0374037A0559064006E506E607F407F507FA081A0824082809710E460EC610FC17D718431AA71C78-1C7D1D2C-1D6A1D781D9B-1DBF2071207F2090-209C2C7C2C7D2D6F2E2F30053031-3035303B309D309E30FC-30FEA015A4F8-A4FDA60CA67FA717-A71FA770A788A7F8A7F9A9CFAA70AADDAAF3AAF4FF70FF9EFF9F",
        Lo: "00AA00BA01BB01C0-01C3029405D0-05EA05F0-05F20620-063F0641-064A066E066F0671-06D306D506EE06EF06FA-06FC06FF07100712-072F074D-07A507B107CA-07EA0800-08150840-085808A008A2-08AC0904-0939093D09500958-09610972-09770979-097F0985-098C098F09900993-09A809AA-09B009B209B6-09B909BD09CE09DC09DD09DF-09E109F009F10A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A59-0A5C0A5E0A72-0A740A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABD0AD00AE00AE10B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3D0B5C0B5D0B5F-0B610B710B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BD00C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D0C580C590C600C610C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBD0CDE0CE00CE10CF10CF20D05-0D0C0D0E-0D100D12-0D3A0D3D0D4E0D600D610D7A-0D7F0D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60E01-0E300E320E330E40-0E450E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB00EB20EB30EBD0EC0-0EC40EDC-0EDF0F000F40-0F470F49-0F6C0F88-0F8C1000-102A103F1050-1055105A-105D106110651066106E-10701075-1081108E10D0-10FA10FD-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A1380-138F13A0-13F41401-166C166F-167F1681-169A16A0-16EA1700-170C170E-17111720-17311740-17511760-176C176E-17701780-17B317DC1820-18421844-18771880-18A818AA18B0-18F51900-191C1950-196D1970-19741980-19AB19C1-19C71A00-1A161A20-1A541B05-1B331B45-1B4B1B83-1BA01BAE1BAF1BBA-1BE51C00-1C231C4D-1C4F1C5A-1C771CE9-1CEC1CEE-1CF11CF51CF62135-21382D30-2D672D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE3006303C3041-3096309F30A1-30FA30FF3105-312D3131-318E31A0-31BA31F0-31FF3400-4DB54E00-9FCCA000-A014A016-A48CA4D0-A4F7A500-A60BA610-A61FA62AA62BA66EA6A0-A6E5A7FB-A801A803-A805A807-A80AA80C-A822A840-A873A882-A8B3A8F2-A8F7A8FBA90A-A925A930-A946A960-A97CA984-A9B2AA00-AA28AA40-AA42AA44-AA4BAA60-AA6FAA71-AA76AA7AAA80-AAAFAAB1AAB5AAB6AAB9-AABDAAC0AAC2AADBAADCAAE0-AAEAAAF2AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABE2AC00-D7A3D7B0-D7C6D7CB-D7FBF900-FA6DFA70-FAD9FB1DFB1F-FB28FB2A-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBB1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFBFE70-FE74FE76-FEFCFF66-FF6FFF71-FF9DFFA0-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC",
        M: "0300-036F0483-04890591-05BD05BF05C105C205C405C505C70610-061A064B-065F067006D6-06DC06DF-06E406E706E806EA-06ED07110730-074A07A6-07B007EB-07F30816-0819081B-08230825-08270829-082D0859-085B08E4-08FE0900-0903093A-093C093E-094F0951-0957096209630981-098309BC09BE-09C409C709C809CB-09CD09D709E209E30A01-0A030A3C0A3E-0A420A470A480A4B-0A4D0A510A700A710A750A81-0A830ABC0ABE-0AC50AC7-0AC90ACB-0ACD0AE20AE30B01-0B030B3C0B3E-0B440B470B480B4B-0B4D0B560B570B620B630B820BBE-0BC20BC6-0BC80BCA-0BCD0BD70C01-0C030C3E-0C440C46-0C480C4A-0C4D0C550C560C620C630C820C830CBC0CBE-0CC40CC6-0CC80CCA-0CCD0CD50CD60CE20CE30D020D030D3E-0D440D46-0D480D4A-0D4D0D570D620D630D820D830DCA0DCF-0DD40DD60DD8-0DDF0DF20DF30E310E34-0E3A0E47-0E4E0EB10EB4-0EB90EBB0EBC0EC8-0ECD0F180F190F350F370F390F3E0F3F0F71-0F840F860F870F8D-0F970F99-0FBC0FC6102B-103E1056-1059105E-10601062-10641067-106D1071-10741082-108D108F109A-109D135D-135F1712-17141732-1734175217531772177317B4-17D317DD180B-180D18A91920-192B1930-193B19B0-19C019C819C91A17-1A1B1A55-1A5E1A60-1A7C1A7F1B00-1B041B34-1B441B6B-1B731B80-1B821BA1-1BAD1BE6-1BF31C24-1C371CD0-1CD21CD4-1CE81CED1CF2-1CF41DC0-1DE61DFC-1DFF20D0-20F02CEF-2CF12D7F2DE0-2DFF302A-302F3099309AA66F-A672A674-A67DA69FA6F0A6F1A802A806A80BA823-A827A880A881A8B4-A8C4A8E0-A8F1A926-A92DA947-A953A980-A983A9B3-A9C0AA29-AA36AA43AA4CAA4DAA7BAAB0AAB2-AAB4AAB7AAB8AABEAABFAAC1AAEB-AAEFAAF5AAF6ABE3-ABEAABECABEDFB1EFE00-FE0FFE20-FE26",
        Mn: "0300-036F0483-04870591-05BD05BF05C105C205C405C505C70610-061A064B-065F067006D6-06DC06DF-06E406E706E806EA-06ED07110730-074A07A6-07B007EB-07F30816-0819081B-08230825-08270829-082D0859-085B08E4-08FE0900-0902093A093C0941-0948094D0951-095709620963098109BC09C1-09C409CD09E209E30A010A020A3C0A410A420A470A480A4B-0A4D0A510A700A710A750A810A820ABC0AC1-0AC50AC70AC80ACD0AE20AE30B010B3C0B3F0B41-0B440B4D0B560B620B630B820BC00BCD0C3E-0C400C46-0C480C4A-0C4D0C550C560C620C630CBC0CBF0CC60CCC0CCD0CE20CE30D41-0D440D4D0D620D630DCA0DD2-0DD40DD60E310E34-0E3A0E47-0E4E0EB10EB4-0EB90EBB0EBC0EC8-0ECD0F180F190F350F370F390F71-0F7E0F80-0F840F860F870F8D-0F970F99-0FBC0FC6102D-10301032-10371039103A103D103E10581059105E-10601071-1074108210851086108D109D135D-135F1712-17141732-1734175217531772177317B417B517B7-17BD17C617C9-17D317DD180B-180D18A91920-19221927192819321939-193B1A171A181A561A58-1A5E1A601A621A65-1A6C1A73-1A7C1A7F1B00-1B031B341B36-1B3A1B3C1B421B6B-1B731B801B811BA2-1BA51BA81BA91BAB1BE61BE81BE91BED1BEF-1BF11C2C-1C331C361C371CD0-1CD21CD4-1CE01CE2-1CE81CED1CF41DC0-1DE61DFC-1DFF20D0-20DC20E120E5-20F02CEF-2CF12D7F2DE0-2DFF302A-302D3099309AA66FA674-A67DA69FA6F0A6F1A802A806A80BA825A826A8C4A8E0-A8F1A926-A92DA947-A951A980-A982A9B3A9B6-A9B9A9BCAA29-AA2EAA31AA32AA35AA36AA43AA4CAAB0AAB2-AAB4AAB7AAB8AABEAABFAAC1AAECAAEDAAF6ABE5ABE8ABEDFB1EFE00-FE0FFE20-FE26",
        Mc: "0903093B093E-09400949-094C094E094F0982098309BE-09C009C709C809CB09CC09D70A030A3E-0A400A830ABE-0AC00AC90ACB0ACC0B020B030B3E0B400B470B480B4B0B4C0B570BBE0BBF0BC10BC20BC6-0BC80BCA-0BCC0BD70C01-0C030C41-0C440C820C830CBE0CC0-0CC40CC70CC80CCA0CCB0CD50CD60D020D030D3E-0D400D46-0D480D4A-0D4C0D570D820D830DCF-0DD10DD8-0DDF0DF20DF30F3E0F3F0F7F102B102C10311038103B103C105610571062-10641067-106D108310841087-108C108F109A-109C17B617BE-17C517C717C81923-19261929-192B193019311933-193819B0-19C019C819C91A19-1A1B1A551A571A611A631A641A6D-1A721B041B351B3B1B3D-1B411B431B441B821BA11BA61BA71BAA1BAC1BAD1BE71BEA-1BEC1BEE1BF21BF31C24-1C2B1C341C351CE11CF21CF3302E302FA823A824A827A880A881A8B4-A8C3A952A953A983A9B4A9B5A9BAA9BBA9BD-A9C0AA2FAA30AA33AA34AA4DAA7BAAEBAAEEAAEFAAF5ABE3ABE4ABE6ABE7ABE9ABEAABEC",
        Me: "0488048920DD-20E020E2-20E4A670-A672",
        N: "0030-003900B200B300B900BC-00BE0660-066906F0-06F907C0-07C90966-096F09E6-09EF09F4-09F90A66-0A6F0AE6-0AEF0B66-0B6F0B72-0B770BE6-0BF20C66-0C6F0C78-0C7E0CE6-0CEF0D66-0D750E50-0E590ED0-0ED90F20-0F331040-10491090-10991369-137C16EE-16F017E0-17E917F0-17F91810-18191946-194F19D0-19DA1A80-1A891A90-1A991B50-1B591BB0-1BB91C40-1C491C50-1C5920702074-20792080-20892150-21822185-21892460-249B24EA-24FF2776-27932CFD30073021-30293038-303A3192-31953220-32293248-324F3251-325F3280-328932B1-32BFA620-A629A6E6-A6EFA830-A835A8D0-A8D9A900-A909A9D0-A9D9AA50-AA59ABF0-ABF9FF10-FF19",
        Nd: "0030-00390660-066906F0-06F907C0-07C90966-096F09E6-09EF0A66-0A6F0AE6-0AEF0B66-0B6F0BE6-0BEF0C66-0C6F0CE6-0CEF0D66-0D6F0E50-0E590ED0-0ED90F20-0F291040-10491090-109917E0-17E91810-18191946-194F19D0-19D91A80-1A891A90-1A991B50-1B591BB0-1BB91C40-1C491C50-1C59A620-A629A8D0-A8D9A900-A909A9D0-A9D9AA50-AA59ABF0-ABF9FF10-FF19",
        Nl: "16EE-16F02160-21822185-218830073021-30293038-303AA6E6-A6EF",
        No: "00B200B300B900BC-00BE09F4-09F90B72-0B770BF0-0BF20C78-0C7E0D70-0D750F2A-0F331369-137C17F0-17F919DA20702074-20792080-20892150-215F21892460-249B24EA-24FF2776-27932CFD3192-31953220-32293248-324F3251-325F3280-328932B1-32BFA830-A835",
        P: "0021-00230025-002A002C-002F003A003B003F0040005B-005D005F007B007D00A100A700AB00B600B700BB00BF037E0387055A-055F0589058A05BE05C005C305C605F305F40609060A060C060D061B061E061F066A-066D06D40700-070D07F7-07F90830-083E085E0964096509700AF00DF40E4F0E5A0E5B0F04-0F120F140F3A-0F3D0F850FD0-0FD40FD90FDA104A-104F10FB1360-13681400166D166E169B169C16EB-16ED1735173617D4-17D617D8-17DA1800-180A194419451A1E1A1F1AA0-1AA61AA8-1AAD1B5A-1B601BFC-1BFF1C3B-1C3F1C7E1C7F1CC0-1CC71CD32010-20272030-20432045-20512053-205E207D207E208D208E2329232A2768-277527C527C627E6-27EF2983-299829D8-29DB29FC29FD2CF9-2CFC2CFE2CFF2D702E00-2E2E2E30-2E3B3001-30033008-30113014-301F3030303D30A030FBA4FEA4FFA60D-A60FA673A67EA6F2-A6F7A874-A877A8CEA8CFA8F8-A8FAA92EA92FA95FA9C1-A9CDA9DEA9DFAA5C-AA5FAADEAADFAAF0AAF1ABEBFD3EFD3FFE10-FE19FE30-FE52FE54-FE61FE63FE68FE6AFE6BFF01-FF03FF05-FF0AFF0C-FF0FFF1AFF1BFF1FFF20FF3B-FF3DFF3FFF5BFF5DFF5F-FF65",
        Pd: "002D058A05BE140018062010-20152E172E1A2E3A2E3B301C303030A0FE31FE32FE58FE63FF0D",
        Ps: "0028005B007B0F3A0F3C169B201A201E2045207D208D23292768276A276C276E27702772277427C527E627E827EA27EC27EE2983298529872989298B298D298F299129932995299729D829DA29FC2E222E242E262E283008300A300C300E3010301430163018301A301DFD3EFE17FE35FE37FE39FE3BFE3DFE3FFE41FE43FE47FE59FE5BFE5DFF08FF3BFF5BFF5FFF62",
        Pe: "0029005D007D0F3B0F3D169C2046207E208E232A2769276B276D276F27712773277527C627E727E927EB27ED27EF298429862988298A298C298E2990299229942996299829D929DB29FD2E232E252E272E293009300B300D300F3011301530173019301B301E301FFD3FFE18FE36FE38FE3AFE3CFE3EFE40FE42FE44FE48FE5AFE5CFE5EFF09FF3DFF5DFF60FF63",
        Pi: "00AB2018201B201C201F20392E022E042E092E0C2E1C2E20",
        Pf: "00BB2019201D203A2E032E052E0A2E0D2E1D2E21",
        Pc: "005F203F20402054FE33FE34FE4D-FE4FFF3F",
        Po: "0021-00230025-0027002A002C002E002F003A003B003F0040005C00A100A700B600B700BF037E0387055A-055F058905C005C305C605F305F40609060A060C060D061B061E061F066A-066D06D40700-070D07F7-07F90830-083E085E0964096509700AF00DF40E4F0E5A0E5B0F04-0F120F140F850FD0-0FD40FD90FDA104A-104F10FB1360-1368166D166E16EB-16ED1735173617D4-17D617D8-17DA1800-18051807-180A194419451A1E1A1F1AA0-1AA61AA8-1AAD1B5A-1B601BFC-1BFF1C3B-1C3F1C7E1C7F1CC0-1CC71CD3201620172020-20272030-2038203B-203E2041-20432047-205120532055-205E2CF9-2CFC2CFE2CFF2D702E002E012E06-2E082E0B2E0E-2E162E182E192E1B2E1E2E1F2E2A-2E2E2E30-2E393001-3003303D30FBA4FEA4FFA60D-A60FA673A67EA6F2-A6F7A874-A877A8CEA8CFA8F8-A8FAA92EA92FA95FA9C1-A9CDA9DEA9DFAA5C-AA5FAADEAADFAAF0AAF1ABEBFE10-FE16FE19FE30FE45FE46FE49-FE4CFE50-FE52FE54-FE57FE5F-FE61FE68FE6AFE6BFF01-FF03FF05-FF07FF0AFF0CFF0EFF0FFF1AFF1BFF1FFF20FF3CFF61FF64FF65",
        S: "0024002B003C-003E005E0060007C007E00A2-00A600A800A900AC00AE-00B100B400B800D700F702C2-02C502D2-02DF02E5-02EB02ED02EF-02FF03750384038503F60482058F0606-0608060B060E060F06DE06E906FD06FE07F609F209F309FA09FB0AF10B700BF3-0BFA0C7F0D790E3F0F01-0F030F130F15-0F170F1A-0F1F0F340F360F380FBE-0FC50FC7-0FCC0FCE0FCF0FD5-0FD8109E109F1390-139917DB194019DE-19FF1B61-1B6A1B74-1B7C1FBD1FBF-1FC11FCD-1FCF1FDD-1FDF1FED-1FEF1FFD1FFE20442052207A-207C208A-208C20A0-20B9210021012103-21062108210921142116-2118211E-2123212521272129212E213A213B2140-2144214A-214D214F2190-2328232B-23F32400-24262440-244A249C-24E92500-26FF2701-27672794-27C427C7-27E527F0-29822999-29D729DC-29FB29FE-2B4C2B50-2B592CE5-2CEA2E80-2E992E9B-2EF32F00-2FD52FF0-2FFB300430123013302030363037303E303F309B309C319031913196-319F31C0-31E33200-321E322A-324732503260-327F328A-32B032C0-32FE3300-33FF4DC0-4DFFA490-A4C6A700-A716A720A721A789A78AA828-A82BA836-A839AA77-AA79FB29FBB2-FBC1FDFCFDFDFE62FE64-FE66FE69FF04FF0BFF1C-FF1EFF3EFF40FF5CFF5EFFE0-FFE6FFE8-FFEEFFFCFFFD",
        Sm: "002B003C-003E007C007E00AC00B100D700F703F60606-060820442052207A-207C208A-208C21182140-2144214B2190-2194219A219B21A021A321A621AE21CE21CF21D221D421F4-22FF2308-230B23202321237C239B-23B323DC-23E125B725C125F8-25FF266F27C0-27C427C7-27E527F0-27FF2900-29822999-29D729DC-29FB29FE-2AFF2B30-2B442B47-2B4CFB29FE62FE64-FE66FF0BFF1C-FF1EFF5CFF5EFFE2FFE9-FFEC",
        Sc: "002400A2-00A5058F060B09F209F309FB0AF10BF90E3F17DB20A0-20B9A838FDFCFE69FF04FFE0FFE1FFE5FFE6",
        Sk: "005E006000A800AF00B400B802C2-02C502D2-02DF02E5-02EB02ED02EF-02FF0375038403851FBD1FBF-1FC11FCD-1FCF1FDD-1FDF1FED-1FEF1FFD1FFE309B309CA700-A716A720A721A789A78AFBB2-FBC1FF3EFF40FFE3",
        So: "00A600A900AE00B00482060E060F06DE06E906FD06FE07F609FA0B700BF3-0BF80BFA0C7F0D790F01-0F030F130F15-0F170F1A-0F1F0F340F360F380FBE-0FC50FC7-0FCC0FCE0FCF0FD5-0FD8109E109F1390-1399194019DE-19FF1B61-1B6A1B74-1B7C210021012103-210621082109211421162117211E-2123212521272129212E213A213B214A214C214D214F2195-2199219C-219F21A121A221A421A521A7-21AD21AF-21CD21D021D121D321D5-21F32300-2307230C-231F2322-2328232B-237B237D-239A23B4-23DB23E2-23F32400-24262440-244A249C-24E92500-25B625B8-25C025C2-25F72600-266E2670-26FF2701-27672794-27BF2800-28FF2B00-2B2F2B452B462B50-2B592CE5-2CEA2E80-2E992E9B-2EF32F00-2FD52FF0-2FFB300430123013302030363037303E303F319031913196-319F31C0-31E33200-321E322A-324732503260-327F328A-32B032C0-32FE3300-33FF4DC0-4DFFA490-A4C6A828-A82BA836A837A839AA77-AA79FDFDFFE4FFE8FFEDFFEEFFFCFFFD",
        Z: "002000A01680180E2000-200A20282029202F205F3000",
        Zs: "002000A01680180E2000-200A202F205F3000",
        Zl: "2028",
        Zp: "2029",
        C: "0000-001F007F-009F00AD03780379037F-0383038B038D03A20528-05300557055805600588058B-058E059005C8-05CF05EB-05EF05F5-0605061C061D06DD070E070F074B074C07B2-07BF07FB-07FF082E082F083F085C085D085F-089F08A108AD-08E308FF097809800984098D098E0991099209A909B109B3-09B509BA09BB09C509C609C909CA09CF-09D609D8-09DB09DE09E409E509FC-0A000A040A0B-0A0E0A110A120A290A310A340A370A3A0A3B0A3D0A43-0A460A490A4A0A4E-0A500A52-0A580A5D0A5F-0A650A76-0A800A840A8E0A920AA90AB10AB40ABA0ABB0AC60ACA0ACE0ACF0AD1-0ADF0AE40AE50AF2-0B000B040B0D0B0E0B110B120B290B310B340B3A0B3B0B450B460B490B4A0B4E-0B550B58-0B5B0B5E0B640B650B78-0B810B840B8B-0B8D0B910B96-0B980B9B0B9D0BA0-0BA20BA5-0BA70BAB-0BAD0BBA-0BBD0BC3-0BC50BC90BCE0BCF0BD1-0BD60BD8-0BE50BFB-0C000C040C0D0C110C290C340C3A-0C3C0C450C490C4E-0C540C570C5A-0C5F0C640C650C70-0C770C800C810C840C8D0C910CA90CB40CBA0CBB0CC50CC90CCE-0CD40CD7-0CDD0CDF0CE40CE50CF00CF3-0D010D040D0D0D110D3B0D3C0D450D490D4F-0D560D58-0D5F0D640D650D76-0D780D800D810D840D97-0D990DB20DBC0DBE0DBF0DC7-0DC90DCB-0DCE0DD50DD70DE0-0DF10DF5-0E000E3B-0E3E0E5C-0E800E830E850E860E890E8B0E8C0E8E-0E930E980EA00EA40EA60EA80EA90EAC0EBA0EBE0EBF0EC50EC70ECE0ECF0EDA0EDB0EE0-0EFF0F480F6D-0F700F980FBD0FCD0FDB-0FFF10C610C8-10CC10CE10CF1249124E124F12571259125E125F1289128E128F12B112B612B712BF12C112C612C712D7131113161317135B135C137D-137F139A-139F13F5-13FF169D-169F16F1-16FF170D1715-171F1737-173F1754-175F176D17711774-177F17DE17DF17EA-17EF17FA-17FF180F181A-181F1878-187F18AB-18AF18F6-18FF191D-191F192C-192F193C-193F1941-1943196E196F1975-197F19AC-19AF19CA-19CF19DB-19DD1A1C1A1D1A5F1A7D1A7E1A8A-1A8F1A9A-1A9F1AAE-1AFF1B4C-1B4F1B7D-1B7F1BF4-1BFB1C38-1C3A1C4A-1C4C1C80-1CBF1CC8-1CCF1CF7-1CFF1DE7-1DFB1F161F171F1E1F1F1F461F471F4E1F4F1F581F5A1F5C1F5E1F7E1F7F1FB51FC51FD41FD51FDC1FF01FF11FF51FFF200B-200F202A-202E2060-206F20722073208F209D-209F20BA-20CF20F1-20FF218A-218F23F4-23FF2427-243F244B-245F27002B4D-2B4F2B5A-2BFF2C2F2C5F2CF4-2CF82D262D28-2D2C2D2E2D2F2D68-2D6E2D71-2D7E2D97-2D9F2DA72DAF2DB72DBF2DC72DCF2DD72DDF2E3C-2E7F2E9A2EF4-2EFF2FD6-2FEF2FFC-2FFF3040309730983100-3104312E-3130318F31BB-31BF31E4-31EF321F32FF4DB6-4DBF9FCD-9FFFA48D-A48FA4C7-A4CFA62C-A63FA698-A69EA6F8-A6FFA78FA794-A79FA7AB-A7F7A82C-A82FA83A-A83FA878-A87FA8C5-A8CDA8DA-A8DFA8FC-A8FFA954-A95EA97D-A97FA9CEA9DA-A9DDA9E0-A9FFAA37-AA3FAA4EAA4FAA5AAA5BAA7C-AA7FAAC3-AADAAAF7-AB00AB07AB08AB0FAB10AB17-AB1FAB27AB2F-ABBFABEEABEFABFA-ABFFD7A4-D7AFD7C7-D7CAD7FC-F8FFFA6EFA6FFADA-FAFFFB07-FB12FB18-FB1CFB37FB3DFB3FFB42FB45FBC2-FBD2FD40-FD4FFD90FD91FDC8-FDEFFDFEFDFFFE1A-FE1FFE27-FE2FFE53FE67FE6C-FE6FFE75FEFD-FF00FFBF-FFC1FFC8FFC9FFD0FFD1FFD8FFD9FFDD-FFDFFFE7FFEF-FFFBFFFEFFFF",
        Cc: "0000-001F007F-009F",
        Cf: "00AD0600-060406DD070F200B-200F202A-202E2060-2064206A-206FFEFFFFF9-FFFB",
        Co: "E000-F8FF",
        Cs: "D800-DFFF",
        Cn: "03780379037F-0383038B038D03A20528-05300557055805600588058B-058E059005C8-05CF05EB-05EF05F5-05FF0605061C061D070E074B074C07B2-07BF07FB-07FF082E082F083F085C085D085F-089F08A108AD-08E308FF097809800984098D098E0991099209A909B109B3-09B509BA09BB09C509C609C909CA09CF-09D609D8-09DB09DE09E409E509FC-0A000A040A0B-0A0E0A110A120A290A310A340A370A3A0A3B0A3D0A43-0A460A490A4A0A4E-0A500A52-0A580A5D0A5F-0A650A76-0A800A840A8E0A920AA90AB10AB40ABA0ABB0AC60ACA0ACE0ACF0AD1-0ADF0AE40AE50AF2-0B000B040B0D0B0E0B110B120B290B310B340B3A0B3B0B450B460B490B4A0B4E-0B550B58-0B5B0B5E0B640B650B78-0B810B840B8B-0B8D0B910B96-0B980B9B0B9D0BA0-0BA20BA5-0BA70BAB-0BAD0BBA-0BBD0BC3-0BC50BC90BCE0BCF0BD1-0BD60BD8-0BE50BFB-0C000C040C0D0C110C290C340C3A-0C3C0C450C490C4E-0C540C570C5A-0C5F0C640C650C70-0C770C800C810C840C8D0C910CA90CB40CBA0CBB0CC50CC90CCE-0CD40CD7-0CDD0CDF0CE40CE50CF00CF3-0D010D040D0D0D110D3B0D3C0D450D490D4F-0D560D58-0D5F0D640D650D76-0D780D800D810D840D97-0D990DB20DBC0DBE0DBF0DC7-0DC90DCB-0DCE0DD50DD70DE0-0DF10DF5-0E000E3B-0E3E0E5C-0E800E830E850E860E890E8B0E8C0E8E-0E930E980EA00EA40EA60EA80EA90EAC0EBA0EBE0EBF0EC50EC70ECE0ECF0EDA0EDB0EE0-0EFF0F480F6D-0F700F980FBD0FCD0FDB-0FFF10C610C8-10CC10CE10CF1249124E124F12571259125E125F1289128E128F12B112B612B712BF12C112C612C712D7131113161317135B135C137D-137F139A-139F13F5-13FF169D-169F16F1-16FF170D1715-171F1737-173F1754-175F176D17711774-177F17DE17DF17EA-17EF17FA-17FF180F181A-181F1878-187F18AB-18AF18F6-18FF191D-191F192C-192F193C-193F1941-1943196E196F1975-197F19AC-19AF19CA-19CF19DB-19DD1A1C1A1D1A5F1A7D1A7E1A8A-1A8F1A9A-1A9F1AAE-1AFF1B4C-1B4F1B7D-1B7F1BF4-1BFB1C38-1C3A1C4A-1C4C1C80-1CBF1CC8-1CCF1CF7-1CFF1DE7-1DFB1F161F171F1E1F1F1F461F471F4E1F4F1F581F5A1F5C1F5E1F7E1F7F1FB51FC51FD41FD51FDC1FF01FF11FF51FFF2065-206920722073208F209D-209F20BA-20CF20F1-20FF218A-218F23F4-23FF2427-243F244B-245F27002B4D-2B4F2B5A-2BFF2C2F2C5F2CF4-2CF82D262D28-2D2C2D2E2D2F2D68-2D6E2D71-2D7E2D97-2D9F2DA72DAF2DB72DBF2DC72DCF2DD72DDF2E3C-2E7F2E9A2EF4-2EFF2FD6-2FEF2FFC-2FFF3040309730983100-3104312E-3130318F31BB-31BF31E4-31EF321F32FF4DB6-4DBF9FCD-9FFFA48D-A48FA4C7-A4CFA62C-A63FA698-A69EA6F8-A6FFA78FA794-A79FA7AB-A7F7A82C-A82FA83A-A83FA878-A87FA8C5-A8CDA8DA-A8DFA8FC-A8FFA954-A95EA97D-A97FA9CEA9DA-A9DDA9E0-A9FFAA37-AA3FAA4EAA4FAA5AAA5BAA7C-AA7FAAC3-AADAAAF7-AB00AB07AB08AB0FAB10AB17-AB1FAB27AB2F-ABBFABEEABEFABFA-ABFFD7A4-D7AFD7C7-D7CAD7FC-D7FFFA6EFA6FFADA-FAFFFB07-FB12FB18-FB1CFB37FB3DFB3FFB42FB45FBC2-FBD2FD40-FD4FFD90FD91FDC8-FDEFFDFEFDFFFE1A-FE1FFE27-FE2FFE53FE67FE6C-FE6FFE75FEFDFEFEFF00FFBF-FFC1FFC8FFC9FFD0FFD1FFD8FFD9FFDD-FFDFFFE7FFEF-FFF8FFFEFFFF"
    }, {
        //L: "Letter", // Included in the Unicode Base addon
        Ll: "Lowercase_Letter",
        Lu: "Uppercase_Letter",
        Lt: "Titlecase_Letter",
        Lm: "Modifier_Letter",
        Lo: "Other_Letter",
        M: "Mark",
        Mn: "Nonspacing_Mark",
        Mc: "Spacing_Mark",
        Me: "Enclosing_Mark",
        N: "Number",
        Nd: "Decimal_Number",
        Nl: "Letter_Number",
        No: "Other_Number",
        P: "Punctuation",
        Pd: "Dash_Punctuation",
        Ps: "Open_Punctuation",
        Pe: "Close_Punctuation",
        Pi: "Initial_Punctuation",
        Pf: "Final_Punctuation",
        Pc: "Connector_Punctuation",
        Po: "Other_Punctuation",
        S: "Symbol",
        Sm: "Math_Symbol",
        Sc: "Currency_Symbol",
        Sk: "Modifier_Symbol",
        So: "Other_Symbol",
        Z: "Separator",
        Zs: "Space_Separator",
        Zl: "Line_Separator",
        Zp: "Paragraph_Separator",
        C: "Other",
        Cc: "Control",
        Cf: "Format",
        Co: "Private_Use",
        Cs: "Surrogate",
        Cn: "Unassigned"
    });

}(XRegExp));


/***** unicode-scripts.js *****/

/*!
 * XRegExp Unicode Scripts v1.2.0
 * (c) 2010-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds support for all Unicode scripts in the Basic Multilingual Plane (U+0000-U+FFFF).
 * E.g., `\p{Latin}`. Token names are case insensitive, and any spaces, hyphens, and underscores
 * are ignored.
 * @requires XRegExp, XRegExp Unicode Base
 */
(function (XRegExp) {
    "use strict";

    if (!XRegExp.addUnicodePackage) {
        throw new ReferenceError("Unicode Base must be loaded before Unicode Scripts");
    }

    XRegExp.install("extensibility");

    XRegExp.addUnicodePackage({
        Arabic: "0600-06040606-060B060D-061A061E0620-063F0641-064A0656-065E066A-066F0671-06DC06DE-06FF0750-077F08A008A2-08AC08E4-08FEFB50-FBC1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFCFE70-FE74FE76-FEFC",
        Armenian: "0531-05560559-055F0561-0587058A058FFB13-FB17",
        Balinese: "1B00-1B4B1B50-1B7C",
        Bamum: "A6A0-A6F7",
        Batak: "1BC0-1BF31BFC-1BFF",
        Bengali: "0981-09830985-098C098F09900993-09A809AA-09B009B209B6-09B909BC-09C409C709C809CB-09CE09D709DC09DD09DF-09E309E6-09FB",
        Bopomofo: "02EA02EB3105-312D31A0-31BA",
        Braille: "2800-28FF",
        Buginese: "1A00-1A1B1A1E1A1F",
        Buhid: "1740-1753",
        Canadian_Aboriginal: "1400-167F18B0-18F5",
        Cham: "AA00-AA36AA40-AA4DAA50-AA59AA5C-AA5F",
        Cherokee: "13A0-13F4",
        Common: "0000-0040005B-0060007B-00A900AB-00B900BB-00BF00D700F702B9-02DF02E5-02E902EC-02FF0374037E038503870589060C061B061F06400660-066906DD096409650E3F0FD5-0FD810FB16EB-16ED173517361802180318051CD31CE11CE9-1CEC1CEE-1CF31CF51CF62000-200B200E-2064206A-20702074-207E2080-208E20A0-20B92100-21252127-2129212C-21312133-214D214F-215F21892190-23F32400-24262440-244A2460-26FF2701-27FF2900-2B4C2B50-2B592E00-2E3B2FF0-2FFB3000-300430063008-30203030-3037303C-303F309B309C30A030FB30FC3190-319F31C0-31E33220-325F327F-32CF3358-33FF4DC0-4DFFA700-A721A788-A78AA830-A839FD3EFD3FFDFDFE10-FE19FE30-FE52FE54-FE66FE68-FE6BFEFFFF01-FF20FF3B-FF40FF5B-FF65FF70FF9EFF9FFFE0-FFE6FFE8-FFEEFFF9-FFFD",
        Coptic: "03E2-03EF2C80-2CF32CF9-2CFF",
        Cyrillic: "0400-04840487-05271D2B1D782DE0-2DFFA640-A697A69F",
        Devanagari: "0900-09500953-09630966-09770979-097FA8E0-A8FB",
        Ethiopic: "1200-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A135D-137C1380-13992D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDEAB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2E",
        Georgian: "10A0-10C510C710CD10D0-10FA10FC-10FF2D00-2D252D272D2D",
        Glagolitic: "2C00-2C2E2C30-2C5E",
        Greek: "0370-03730375-0377037A-037D038403860388-038A038C038E-03A103A3-03E103F0-03FF1D26-1D2A1D5D-1D611D66-1D6A1DBF1F00-1F151F18-1F1D1F20-1F451F48-1F4D1F50-1F571F591F5B1F5D1F5F-1F7D1F80-1FB41FB6-1FC41FC6-1FD31FD6-1FDB1FDD-1FEF1FF2-1FF41FF6-1FFE2126",
        Gujarati: "0A81-0A830A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABC-0AC50AC7-0AC90ACB-0ACD0AD00AE0-0AE30AE6-0AF1",
        Gurmukhi: "0A01-0A030A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A3C0A3E-0A420A470A480A4B-0A4D0A510A59-0A5C0A5E0A66-0A75",
        Han: "2E80-2E992E9B-2EF32F00-2FD5300530073021-30293038-303B3400-4DB54E00-9FCCF900-FA6DFA70-FAD9",
        Hangul: "1100-11FF302E302F3131-318E3200-321E3260-327EA960-A97CAC00-D7A3D7B0-D7C6D7CB-D7FBFFA0-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC",
        Hanunoo: "1720-1734",
        Hebrew: "0591-05C705D0-05EA05F0-05F4FB1D-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FB4F",
        Hiragana: "3041-3096309D-309F",
        Inherited: "0300-036F04850486064B-0655065F0670095109521CD0-1CD21CD4-1CE01CE2-1CE81CED1CF41DC0-1DE61DFC-1DFF200C200D20D0-20F0302A-302D3099309AFE00-FE0FFE20-FE26",
        Javanese: "A980-A9CDA9CF-A9D9A9DEA9DF",
        Kannada: "0C820C830C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBC-0CC40CC6-0CC80CCA-0CCD0CD50CD60CDE0CE0-0CE30CE6-0CEF0CF10CF2",
        Katakana: "30A1-30FA30FD-30FF31F0-31FF32D0-32FE3300-3357FF66-FF6FFF71-FF9D",
        Kayah_Li: "A900-A92F",
        Khmer: "1780-17DD17E0-17E917F0-17F919E0-19FF",
        Lao: "0E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB90EBB-0EBD0EC0-0EC40EC60EC8-0ECD0ED0-0ED90EDC-0EDF",
        Latin: "0041-005A0061-007A00AA00BA00C0-00D600D8-00F600F8-02B802E0-02E41D00-1D251D2C-1D5C1D62-1D651D6B-1D771D79-1DBE1E00-1EFF2071207F2090-209C212A212B2132214E2160-21882C60-2C7FA722-A787A78B-A78EA790-A793A7A0-A7AAA7F8-A7FFFB00-FB06FF21-FF3AFF41-FF5A",
        Lepcha: "1C00-1C371C3B-1C491C4D-1C4F",
        Limbu: "1900-191C1920-192B1930-193B19401944-194F",
        Lisu: "A4D0-A4FF",
        Malayalam: "0D020D030D05-0D0C0D0E-0D100D12-0D3A0D3D-0D440D46-0D480D4A-0D4E0D570D60-0D630D66-0D750D79-0D7F",
        Mandaic: "0840-085B085E",
        Meetei_Mayek: "AAE0-AAF6ABC0-ABEDABF0-ABF9",
        Mongolian: "1800180118041806-180E1810-18191820-18771880-18AA",
        Myanmar: "1000-109FAA60-AA7B",
        New_Tai_Lue: "1980-19AB19B0-19C919D0-19DA19DE19DF",
        Nko: "07C0-07FA",
        Ogham: "1680-169C",
        Ol_Chiki: "1C50-1C7F",
        Oriya: "0B01-0B030B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3C-0B440B470B480B4B-0B4D0B560B570B5C0B5D0B5F-0B630B66-0B77",
        Phags_Pa: "A840-A877",
        Rejang: "A930-A953A95F",
        Runic: "16A0-16EA16EE-16F0",
        Samaritan: "0800-082D0830-083E",
        Saurashtra: "A880-A8C4A8CE-A8D9",
        Sinhala: "0D820D830D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60DCA0DCF-0DD40DD60DD8-0DDF0DF2-0DF4",
        Sundanese: "1B80-1BBF1CC0-1CC7",
        Syloti_Nagri: "A800-A82B",
        Syriac: "0700-070D070F-074A074D-074F",
        Tagalog: "1700-170C170E-1714",
        Tagbanwa: "1760-176C176E-177017721773",
        Tai_Le: "1950-196D1970-1974",
        Tai_Tham: "1A20-1A5E1A60-1A7C1A7F-1A891A90-1A991AA0-1AAD",
        Tai_Viet: "AA80-AAC2AADB-AADF",
        Tamil: "0B820B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BBE-0BC20BC6-0BC80BCA-0BCD0BD00BD70BE6-0BFA",
        Telugu: "0C01-0C030C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D-0C440C46-0C480C4A-0C4D0C550C560C580C590C60-0C630C66-0C6F0C78-0C7F",
        Thaana: "0780-07B1",
        Thai: "0E01-0E3A0E40-0E5B",
        Tibetan: "0F00-0F470F49-0F6C0F71-0F970F99-0FBC0FBE-0FCC0FCE-0FD40FD90FDA",
        Tifinagh: "2D30-2D672D6F2D702D7F",
        Vai: "A500-A62B",
        Yi: "A000-A48CA490-A4C6"
    });

}(XRegExp));


/***** unicode-blocks.js *****/

/*!
 * XRegExp Unicode Blocks v1.2.0
 * (c) 2010-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds support for all Unicode blocks in the Basic Multilingual Plane (U+0000-U+FFFF). Unicode
 * blocks use the prefix "In". E.g., `\p{InBasicLatin}`. Token names are case insensitive, and any
 * spaces, hyphens, and underscores are ignored.
 * @requires XRegExp, XRegExp Unicode Base
 */
(function (XRegExp) {
    "use strict";

    if (!XRegExp.addUnicodePackage) {
        throw new ReferenceError("Unicode Base must be loaded before Unicode Blocks");
    }

    XRegExp.install("extensibility");

    XRegExp.addUnicodePackage({
        InBasic_Latin: "0000-007F",
        InLatin_1_Supplement: "0080-00FF",
        InLatin_Extended_A: "0100-017F",
        InLatin_Extended_B: "0180-024F",
        InIPA_Extensions: "0250-02AF",
        InSpacing_Modifier_Letters: "02B0-02FF",
        InCombining_Diacritical_Marks: "0300-036F",
        InGreek_and_Coptic: "0370-03FF",
        InCyrillic: "0400-04FF",
        InCyrillic_Supplement: "0500-052F",
        InArmenian: "0530-058F",
        InHebrew: "0590-05FF",
        InArabic: "0600-06FF",
        InSyriac: "0700-074F",
        InArabic_Supplement: "0750-077F",
        InThaana: "0780-07BF",
        InNKo: "07C0-07FF",
        InSamaritan: "0800-083F",
        InMandaic: "0840-085F",
        InArabic_Extended_A: "08A0-08FF",
        InDevanagari: "0900-097F",
        InBengali: "0980-09FF",
        InGurmukhi: "0A00-0A7F",
        InGujarati: "0A80-0AFF",
        InOriya: "0B00-0B7F",
        InTamil: "0B80-0BFF",
        InTelugu: "0C00-0C7F",
        InKannada: "0C80-0CFF",
        InMalayalam: "0D00-0D7F",
        InSinhala: "0D80-0DFF",
        InThai: "0E00-0E7F",
        InLao: "0E80-0EFF",
        InTibetan: "0F00-0FFF",
        InMyanmar: "1000-109F",
        InGeorgian: "10A0-10FF",
        InHangul_Jamo: "1100-11FF",
        InEthiopic: "1200-137F",
        InEthiopic_Supplement: "1380-139F",
        InCherokee: "13A0-13FF",
        InUnified_Canadian_Aboriginal_Syllabics: "1400-167F",
        InOgham: "1680-169F",
        InRunic: "16A0-16FF",
        InTagalog: "1700-171F",
        InHanunoo: "1720-173F",
        InBuhid: "1740-175F",
        InTagbanwa: "1760-177F",
        InKhmer: "1780-17FF",
        InMongolian: "1800-18AF",
        InUnified_Canadian_Aboriginal_Syllabics_Extended: "18B0-18FF",
        InLimbu: "1900-194F",
        InTai_Le: "1950-197F",
        InNew_Tai_Lue: "1980-19DF",
        InKhmer_Symbols: "19E0-19FF",
        InBuginese: "1A00-1A1F",
        InTai_Tham: "1A20-1AAF",
        InBalinese: "1B00-1B7F",
        InSundanese: "1B80-1BBF",
        InBatak: "1BC0-1BFF",
        InLepcha: "1C00-1C4F",
        InOl_Chiki: "1C50-1C7F",
        InSundanese_Supplement: "1CC0-1CCF",
        InVedic_Extensions: "1CD0-1CFF",
        InPhonetic_Extensions: "1D00-1D7F",
        InPhonetic_Extensions_Supplement: "1D80-1DBF",
        InCombining_Diacritical_Marks_Supplement: "1DC0-1DFF",
        InLatin_Extended_Additional: "1E00-1EFF",
        InGreek_Extended: "1F00-1FFF",
        InGeneral_Punctuation: "2000-206F",
        InSuperscripts_and_Subscripts: "2070-209F",
        InCurrency_Symbols: "20A0-20CF",
        InCombining_Diacritical_Marks_for_Symbols: "20D0-20FF",
        InLetterlike_Symbols: "2100-214F",
        InNumber_Forms: "2150-218F",
        InArrows: "2190-21FF",
        InMathematical_Operators: "2200-22FF",
        InMiscellaneous_Technical: "2300-23FF",
        InControl_Pictures: "2400-243F",
        InOptical_Character_Recognition: "2440-245F",
        InEnclosed_Alphanumerics: "2460-24FF",
        InBox_Drawing: "2500-257F",
        InBlock_Elements: "2580-259F",
        InGeometric_Shapes: "25A0-25FF",
        InMiscellaneous_Symbols: "2600-26FF",
        InDingbats: "2700-27BF",
        InMiscellaneous_Mathematical_Symbols_A: "27C0-27EF",
        InSupplemental_Arrows_A: "27F0-27FF",
        InBraille_Patterns: "2800-28FF",
        InSupplemental_Arrows_B: "2900-297F",
        InMiscellaneous_Mathematical_Symbols_B: "2980-29FF",
        InSupplemental_Mathematical_Operators: "2A00-2AFF",
        InMiscellaneous_Symbols_and_Arrows: "2B00-2BFF",
        InGlagolitic: "2C00-2C5F",
        InLatin_Extended_C: "2C60-2C7F",
        InCoptic: "2C80-2CFF",
        InGeorgian_Supplement: "2D00-2D2F",
        InTifinagh: "2D30-2D7F",
        InEthiopic_Extended: "2D80-2DDF",
        InCyrillic_Extended_A: "2DE0-2DFF",
        InSupplemental_Punctuation: "2E00-2E7F",
        InCJK_Radicals_Supplement: "2E80-2EFF",
        InKangxi_Radicals: "2F00-2FDF",
        InIdeographic_Description_Characters: "2FF0-2FFF",
        InCJK_Symbols_and_Punctuation: "3000-303F",
        InHiragana: "3040-309F",
        InKatakana: "30A0-30FF",
        InBopomofo: "3100-312F",
        InHangul_Compatibility_Jamo: "3130-318F",
        InKanbun: "3190-319F",
        InBopomofo_Extended: "31A0-31BF",
        InCJK_Strokes: "31C0-31EF",
        InKatakana_Phonetic_Extensions: "31F0-31FF",
        InEnclosed_CJK_Letters_and_Months: "3200-32FF",
        InCJK_Compatibility: "3300-33FF",
        InCJK_Unified_Ideographs_Extension_A: "3400-4DBF",
        InYijing_Hexagram_Symbols: "4DC0-4DFF",
        InCJK_Unified_Ideographs: "4E00-9FFF",
        InYi_Syllables: "A000-A48F",
        InYi_Radicals: "A490-A4CF",
        InLisu: "A4D0-A4FF",
        InVai: "A500-A63F",
        InCyrillic_Extended_B: "A640-A69F",
        InBamum: "A6A0-A6FF",
        InModifier_Tone_Letters: "A700-A71F",
        InLatin_Extended_D: "A720-A7FF",
        InSyloti_Nagri: "A800-A82F",
        InCommon_Indic_Number_Forms: "A830-A83F",
        InPhags_pa: "A840-A87F",
        InSaurashtra: "A880-A8DF",
        InDevanagari_Extended: "A8E0-A8FF",
        InKayah_Li: "A900-A92F",
        InRejang: "A930-A95F",
        InHangul_Jamo_Extended_A: "A960-A97F",
        InJavanese: "A980-A9DF",
        InCham: "AA00-AA5F",
        InMyanmar_Extended_A: "AA60-AA7F",
        InTai_Viet: "AA80-AADF",
        InMeetei_Mayek_Extensions: "AAE0-AAFF",
        InEthiopic_Extended_A: "AB00-AB2F",
        InMeetei_Mayek: "ABC0-ABFF",
        InHangul_Syllables: "AC00-D7AF",
        InHangul_Jamo_Extended_B: "D7B0-D7FF",
        InHigh_Surrogates: "D800-DB7F",
        InHigh_Private_Use_Surrogates: "DB80-DBFF",
        InLow_Surrogates: "DC00-DFFF",
        InPrivate_Use_Area: "E000-F8FF",
        InCJK_Compatibility_Ideographs: "F900-FAFF",
        InAlphabetic_Presentation_Forms: "FB00-FB4F",
        InArabic_Presentation_Forms_A: "FB50-FDFF",
        InVariation_Selectors: "FE00-FE0F",
        InVertical_Forms: "FE10-FE1F",
        InCombining_Half_Marks: "FE20-FE2F",
        InCJK_Compatibility_Forms: "FE30-FE4F",
        InSmall_Form_Variants: "FE50-FE6F",
        InArabic_Presentation_Forms_B: "FE70-FEFF",
        InHalfwidth_and_Fullwidth_Forms: "FF00-FFEF",
        InSpecials: "FFF0-FFFF"
    });

}(XRegExp));


/***** unicode-properties.js *****/

/*!
 * XRegExp Unicode Properties v1.0.0
 * (c) 2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Uses Unicode 6.1 <http://unicode.org/>
 */

/**
 * Adds Unicode properties necessary to meet Level 1 Unicode support (detailed in UTS#18 RL1.2).
 * Includes code points from the Basic Multilingual Plane (U+0000-U+FFFF) only. Token names are
 * case insensitive, and any spaces, hyphens, and underscores are ignored.
 * @requires XRegExp, XRegExp Unicode Base
 */
(function (XRegExp) {
    "use strict";

    if (!XRegExp.addUnicodePackage) {
        throw new ReferenceError("Unicode Base must be loaded before Unicode Properties");
    }

    XRegExp.install("extensibility");

    XRegExp.addUnicodePackage({
        Alphabetic: "0041-005A0061-007A00AA00B500BA00C0-00D600D8-00F600F8-02C102C6-02D102E0-02E402EC02EE03450370-037403760377037A-037D03860388-038A038C038E-03A103A3-03F503F7-0481048A-05270531-055605590561-058705B0-05BD05BF05C105C205C405C505C705D0-05EA05F0-05F20610-061A0620-06570659-065F066E-06D306D5-06DC06E1-06E806ED-06EF06FA-06FC06FF0710-073F074D-07B107CA-07EA07F407F507FA0800-0817081A-082C0840-085808A008A2-08AC08E4-08E908F0-08FE0900-093B093D-094C094E-09500955-09630971-09770979-097F0981-09830985-098C098F09900993-09A809AA-09B009B209B6-09B909BD-09C409C709C809CB09CC09CE09D709DC09DD09DF-09E309F009F10A01-0A030A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A3E-0A420A470A480A4B0A4C0A510A59-0A5C0A5E0A70-0A750A81-0A830A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABD-0AC50AC7-0AC90ACB0ACC0AD00AE0-0AE30B01-0B030B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3D-0B440B470B480B4B0B4C0B560B570B5C0B5D0B5F-0B630B710B820B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BBE-0BC20BC6-0BC80BCA-0BCC0BD00BD70C01-0C030C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D-0C440C46-0C480C4A-0C4C0C550C560C580C590C60-0C630C820C830C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBD-0CC40CC6-0CC80CCA-0CCC0CD50CD60CDE0CE0-0CE30CF10CF20D020D030D05-0D0C0D0E-0D100D12-0D3A0D3D-0D440D46-0D480D4A-0D4C0D4E0D570D60-0D630D7A-0D7F0D820D830D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60DCF-0DD40DD60DD8-0DDF0DF20DF30E01-0E3A0E40-0E460E4D0E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB90EBB-0EBD0EC0-0EC40EC60ECD0EDC-0EDF0F000F40-0F470F49-0F6C0F71-0F810F88-0F970F99-0FBC1000-10361038103B-103F1050-10621065-1068106E-1086108E109C109D10A0-10C510C710CD10D0-10FA10FC-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A135F1380-138F13A0-13F41401-166C166F-167F1681-169A16A0-16EA16EE-16F01700-170C170E-17131720-17331740-17531760-176C176E-1770177217731780-17B317B6-17C817D717DC1820-18771880-18AA18B0-18F51900-191C1920-192B1930-19381950-196D1970-19741980-19AB19B0-19C91A00-1A1B1A20-1A5E1A61-1A741AA71B00-1B331B35-1B431B45-1B4B1B80-1BA91BAC-1BAF1BBA-1BE51BE7-1BF11C00-1C351C4D-1C4F1C5A-1C7D1CE9-1CEC1CEE-1CF31CF51CF61D00-1DBF1E00-1F151F18-1F1D1F20-1F451F48-1F4D1F50-1F571F591F5B1F5D1F5F-1F7D1F80-1FB41FB6-1FBC1FBE1FC2-1FC41FC6-1FCC1FD0-1FD31FD6-1FDB1FE0-1FEC1FF2-1FF41FF6-1FFC2071207F2090-209C21022107210A-211321152119-211D212421262128212A-212D212F-2139213C-213F2145-2149214E2160-218824B6-24E92C00-2C2E2C30-2C5E2C60-2CE42CEB-2CEE2CF22CF32D00-2D252D272D2D2D30-2D672D6F2D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE2DE0-2DFF2E2F3005-30073021-30293031-30353038-303C3041-3096309D-309F30A1-30FA30FC-30FF3105-312D3131-318E31A0-31BA31F0-31FF3400-4DB54E00-9FCCA000-A48CA4D0-A4FDA500-A60CA610-A61FA62AA62BA640-A66EA674-A67BA67F-A697A69F-A6EFA717-A71FA722-A788A78B-A78EA790-A793A7A0-A7AAA7F8-A801A803-A805A807-A80AA80C-A827A840-A873A880-A8C3A8F2-A8F7A8FBA90A-A92AA930-A952A960-A97CA980-A9B2A9B4-A9BFA9CFAA00-AA36AA40-AA4DAA60-AA76AA7AAA80-AABEAAC0AAC2AADB-AADDAAE0-AAEFAAF2-AAF5AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABEAAC00-D7A3D7B0-D7C6D7CB-D7FBF900-FA6DFA70-FAD9FB00-FB06FB13-FB17FB1D-FB28FB2A-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBB1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFBFE70-FE74FE76-FEFCFF21-FF3AFF41-FF5AFF66-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC",
        Uppercase: "0041-005A00C0-00D600D8-00DE01000102010401060108010A010C010E01100112011401160118011A011C011E01200122012401260128012A012C012E01300132013401360139013B013D013F0141014301450147014A014C014E01500152015401560158015A015C015E01600162016401660168016A016C016E017001720174017601780179017B017D018101820184018601870189-018B018E-0191019301940196-0198019C019D019F01A001A201A401A601A701A901AC01AE01AF01B1-01B301B501B701B801BC01C401C701CA01CD01CF01D101D301D501D701D901DB01DE01E001E201E401E601E801EA01EC01EE01F101F401F6-01F801FA01FC01FE02000202020402060208020A020C020E02100212021402160218021A021C021E02200222022402260228022A022C022E02300232023A023B023D023E02410243-02460248024A024C024E03700372037603860388-038A038C038E038F0391-03A103A3-03AB03CF03D2-03D403D803DA03DC03DE03E003E203E403E603E803EA03EC03EE03F403F703F903FA03FD-042F04600462046404660468046A046C046E04700472047404760478047A047C047E0480048A048C048E04900492049404960498049A049C049E04A004A204A404A604A804AA04AC04AE04B004B204B404B604B804BA04BC04BE04C004C104C304C504C704C904CB04CD04D004D204D404D604D804DA04DC04DE04E004E204E404E604E804EA04EC04EE04F004F204F404F604F804FA04FC04FE05000502050405060508050A050C050E05100512051405160518051A051C051E05200522052405260531-055610A0-10C510C710CD1E001E021E041E061E081E0A1E0C1E0E1E101E121E141E161E181E1A1E1C1E1E1E201E221E241E261E281E2A1E2C1E2E1E301E321E341E361E381E3A1E3C1E3E1E401E421E441E461E481E4A1E4C1E4E1E501E521E541E561E581E5A1E5C1E5E1E601E621E641E661E681E6A1E6C1E6E1E701E721E741E761E781E7A1E7C1E7E1E801E821E841E861E881E8A1E8C1E8E1E901E921E941E9E1EA01EA21EA41EA61EA81EAA1EAC1EAE1EB01EB21EB41EB61EB81EBA1EBC1EBE1EC01EC21EC41EC61EC81ECA1ECC1ECE1ED01ED21ED41ED61ED81EDA1EDC1EDE1EE01EE21EE41EE61EE81EEA1EEC1EEE1EF01EF21EF41EF61EF81EFA1EFC1EFE1F08-1F0F1F18-1F1D1F28-1F2F1F38-1F3F1F48-1F4D1F591F5B1F5D1F5F1F68-1F6F1FB8-1FBB1FC8-1FCB1FD8-1FDB1FE8-1FEC1FF8-1FFB21022107210B-210D2110-211221152119-211D212421262128212A-212D2130-2133213E213F21452160-216F218324B6-24CF2C00-2C2E2C602C62-2C642C672C692C6B2C6D-2C702C722C752C7E-2C802C822C842C862C882C8A2C8C2C8E2C902C922C942C962C982C9A2C9C2C9E2CA02CA22CA42CA62CA82CAA2CAC2CAE2CB02CB22CB42CB62CB82CBA2CBC2CBE2CC02CC22CC42CC62CC82CCA2CCC2CCE2CD02CD22CD42CD62CD82CDA2CDC2CDE2CE02CE22CEB2CED2CF2A640A642A644A646A648A64AA64CA64EA650A652A654A656A658A65AA65CA65EA660A662A664A666A668A66AA66CA680A682A684A686A688A68AA68CA68EA690A692A694A696A722A724A726A728A72AA72CA72EA732A734A736A738A73AA73CA73EA740A742A744A746A748A74AA74CA74EA750A752A754A756A758A75AA75CA75EA760A762A764A766A768A76AA76CA76EA779A77BA77DA77EA780A782A784A786A78BA78DA790A792A7A0A7A2A7A4A7A6A7A8A7AAFF21-FF3A",
        Lowercase: "0061-007A00AA00B500BA00DF-00F600F8-00FF01010103010501070109010B010D010F01110113011501170119011B011D011F01210123012501270129012B012D012F01310133013501370138013A013C013E014001420144014601480149014B014D014F01510153015501570159015B015D015F01610163016501670169016B016D016F0171017301750177017A017C017E-0180018301850188018C018D019201950199-019B019E01A101A301A501A801AA01AB01AD01B001B401B601B901BA01BD-01BF01C601C901CC01CE01D001D201D401D601D801DA01DC01DD01DF01E101E301E501E701E901EB01ED01EF01F001F301F501F901FB01FD01FF02010203020502070209020B020D020F02110213021502170219021B021D021F02210223022502270229022B022D022F02310233-0239023C023F0240024202470249024B024D024F-02930295-02B802C002C102E0-02E40345037103730377037A-037D039003AC-03CE03D003D103D5-03D703D903DB03DD03DF03E103E303E503E703E903EB03ED03EF-03F303F503F803FB03FC0430-045F04610463046504670469046B046D046F04710473047504770479047B047D047F0481048B048D048F04910493049504970499049B049D049F04A104A304A504A704A904AB04AD04AF04B104B304B504B704B904BB04BD04BF04C204C404C604C804CA04CC04CE04CF04D104D304D504D704D904DB04DD04DF04E104E304E504E704E904EB04ED04EF04F104F304F504F704F904FB04FD04FF05010503050505070509050B050D050F05110513051505170519051B051D051F05210523052505270561-05871D00-1DBF1E011E031E051E071E091E0B1E0D1E0F1E111E131E151E171E191E1B1E1D1E1F1E211E231E251E271E291E2B1E2D1E2F1E311E331E351E371E391E3B1E3D1E3F1E411E431E451E471E491E4B1E4D1E4F1E511E531E551E571E591E5B1E5D1E5F1E611E631E651E671E691E6B1E6D1E6F1E711E731E751E771E791E7B1E7D1E7F1E811E831E851E871E891E8B1E8D1E8F1E911E931E95-1E9D1E9F1EA11EA31EA51EA71EA91EAB1EAD1EAF1EB11EB31EB51EB71EB91EBB1EBD1EBF1EC11EC31EC51EC71EC91ECB1ECD1ECF1ED11ED31ED51ED71ED91EDB1EDD1EDF1EE11EE31EE51EE71EE91EEB1EED1EEF1EF11EF31EF51EF71EF91EFB1EFD1EFF-1F071F10-1F151F20-1F271F30-1F371F40-1F451F50-1F571F60-1F671F70-1F7D1F80-1F871F90-1F971FA0-1FA71FB0-1FB41FB61FB71FBE1FC2-1FC41FC61FC71FD0-1FD31FD61FD71FE0-1FE71FF2-1FF41FF61FF72071207F2090-209C210A210E210F2113212F21342139213C213D2146-2149214E2170-217F218424D0-24E92C30-2C5E2C612C652C662C682C6A2C6C2C712C732C742C76-2C7D2C812C832C852C872C892C8B2C8D2C8F2C912C932C952C972C992C9B2C9D2C9F2CA12CA32CA52CA72CA92CAB2CAD2CAF2CB12CB32CB52CB72CB92CBB2CBD2CBF2CC12CC32CC52CC72CC92CCB2CCD2CCF2CD12CD32CD52CD72CD92CDB2CDD2CDF2CE12CE32CE42CEC2CEE2CF32D00-2D252D272D2DA641A643A645A647A649A64BA64DA64FA651A653A655A657A659A65BA65DA65FA661A663A665A667A669A66BA66DA681A683A685A687A689A68BA68DA68FA691A693A695A697A723A725A727A729A72BA72DA72F-A731A733A735A737A739A73BA73DA73FA741A743A745A747A749A74BA74DA74FA751A753A755A757A759A75BA75DA75FA761A763A765A767A769A76BA76DA76F-A778A77AA77CA77FA781A783A785A787A78CA78EA791A793A7A1A7A3A7A5A7A7A7A9A7F8-A7FAFB00-FB06FB13-FB17FF41-FF5A",
        White_Space: "0009-000D0020008500A01680180E2000-200A20282029202F205F3000",
        Noncharacter_Code_Point: "FDD0-FDEFFFFEFFFF",
        Default_Ignorable_Code_Point: "00AD034F115F116017B417B5180B-180D200B-200F202A-202E2060-206F3164FE00-FE0FFEFFFFA0FFF0-FFF8",
        // \p{Any} matches a code unit. To match any code point via surrogate pairs, use (?:[\0-\uD7FF\uDC00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF])
        Any: "0000-FFFF", // \p{^Any} compiles to [^\u0000-\uFFFF]; [\p{^Any}] to []
        Ascii: "0000-007F",
        // \p{Assigned} is equivalent to \p{^Cn}
        //Assigned: XRegExp("[\\p{^Cn}]").source.replace(/[[\]]|\\u/g, "") // Negation inside a character class triggers inversion
        Assigned: "0000-0377037A-037E0384-038A038C038E-03A103A3-05270531-05560559-055F0561-05870589058A058F0591-05C705D0-05EA05F0-05F40600-06040606-061B061E-070D070F-074A074D-07B107C0-07FA0800-082D0830-083E0840-085B085E08A008A2-08AC08E4-08FE0900-09770979-097F0981-09830985-098C098F09900993-09A809AA-09B009B209B6-09B909BC-09C409C709C809CB-09CE09D709DC09DD09DF-09E309E6-09FB0A01-0A030A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A3C0A3E-0A420A470A480A4B-0A4D0A510A59-0A5C0A5E0A66-0A750A81-0A830A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABC-0AC50AC7-0AC90ACB-0ACD0AD00AE0-0AE30AE6-0AF10B01-0B030B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3C-0B440B470B480B4B-0B4D0B560B570B5C0B5D0B5F-0B630B66-0B770B820B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BBE-0BC20BC6-0BC80BCA-0BCD0BD00BD70BE6-0BFA0C01-0C030C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D-0C440C46-0C480C4A-0C4D0C550C560C580C590C60-0C630C66-0C6F0C78-0C7F0C820C830C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBC-0CC40CC6-0CC80CCA-0CCD0CD50CD60CDE0CE0-0CE30CE6-0CEF0CF10CF20D020D030D05-0D0C0D0E-0D100D12-0D3A0D3D-0D440D46-0D480D4A-0D4E0D570D60-0D630D66-0D750D79-0D7F0D820D830D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60DCA0DCF-0DD40DD60DD8-0DDF0DF2-0DF40E01-0E3A0E3F-0E5B0E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB90EBB-0EBD0EC0-0EC40EC60EC8-0ECD0ED0-0ED90EDC-0EDF0F00-0F470F49-0F6C0F71-0F970F99-0FBC0FBE-0FCC0FCE-0FDA1000-10C510C710CD10D0-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A135D-137C1380-139913A0-13F41400-169C16A0-16F01700-170C170E-17141720-17361740-17531760-176C176E-1770177217731780-17DD17E0-17E917F0-17F91800-180E1810-18191820-18771880-18AA18B0-18F51900-191C1920-192B1930-193B19401944-196D1970-19741980-19AB19B0-19C919D0-19DA19DE-1A1B1A1E-1A5E1A60-1A7C1A7F-1A891A90-1A991AA0-1AAD1B00-1B4B1B50-1B7C1B80-1BF31BFC-1C371C3B-1C491C4D-1C7F1CC0-1CC71CD0-1CF61D00-1DE61DFC-1F151F18-1F1D1F20-1F451F48-1F4D1F50-1F571F591F5B1F5D1F5F-1F7D1F80-1FB41FB6-1FC41FC6-1FD31FD6-1FDB1FDD-1FEF1FF2-1FF41FF6-1FFE2000-2064206A-20712074-208E2090-209C20A0-20B920D0-20F02100-21892190-23F32400-24262440-244A2460-26FF2701-2B4C2B50-2B592C00-2C2E2C30-2C5E2C60-2CF32CF9-2D252D272D2D2D30-2D672D6F2D702D7F-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE2DE0-2E3B2E80-2E992E9B-2EF32F00-2FD52FF0-2FFB3000-303F3041-30963099-30FF3105-312D3131-318E3190-31BA31C0-31E331F0-321E3220-32FE3300-4DB54DC0-9FCCA000-A48CA490-A4C6A4D0-A62BA640-A697A69F-A6F7A700-A78EA790-A793A7A0-A7AAA7F8-A82BA830-A839A840-A877A880-A8C4A8CE-A8D9A8E0-A8FBA900-A953A95F-A97CA980-A9CDA9CF-A9D9A9DEA9DFAA00-AA36AA40-AA4DAA50-AA59AA5C-AA7BAA80-AAC2AADB-AAF6AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABEDABF0-ABF9AC00-D7A3D7B0-D7C6D7CB-D7FBD800-FA6DFA70-FAD9FB00-FB06FB13-FB17FB1D-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBC1FBD3-FD3FFD50-FD8FFD92-FDC7FDF0-FDFDFE00-FE19FE20-FE26FE30-FE52FE54-FE66FE68-FE6BFE70-FE74FE76-FEFCFEFFFF01-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDCFFE0-FFE6FFE8-FFEEFFF9-FFFD"
    });

}(XRegExp));


/***** matchrecursive.js *****/

/*!
 * XRegExp.matchRecursive v0.2.0
 * (c) 2009-2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 */

(function (XRegExp) {
    "use strict";

/**
 * Returns a match detail object composed of the provided values.
 * @private
 */
    function row(value, name, start, end) {
        return {value:value, name:name, start:start, end:end};
    }

/**
 * Returns an array of match strings between outermost left and right delimiters, or an array of
 * objects with detailed match parts and position data. An error is thrown if delimiters are
 * unbalanced within the data.
 * @memberOf XRegExp
 * @param {String} str String to search.
 * @param {String} left Left delimiter as an XRegExp pattern.
 * @param {String} right Right delimiter as an XRegExp pattern.
 * @param {String} [flags] Flags for the left and right delimiters. Use any of: `gimnsxy`.
 * @param {Object} [options] Lets you specify `valueNames` and `escapeChar` options.
 * @returns {Array} Array of matches, or an empty array.
 * @example
 *
 * // Basic usage
 * var str = '(t((e))s)t()(ing)';
 * XRegExp.matchRecursive(str, '\\(', '\\)', 'g');
 * // -> ['t((e))s', '', 'ing']
 *
 * // Extended information mode with valueNames
 * str = 'Here is <div> <div>an</div></div> example';
 * XRegExp.matchRecursive(str, '<div\\s*>', '</div>', 'gi', {
 *   valueNames: ['between', 'left', 'match', 'right']
 * });
 * // -> [
 * // {name: 'between', value: 'Here is ',       start: 0,  end: 8},
 * // {name: 'left',    value: '<div>',          start: 8,  end: 13},
 * // {name: 'match',   value: ' <div>an</div>', start: 13, end: 27},
 * // {name: 'right',   value: '</div>',         start: 27, end: 33},
 * // {name: 'between', value: ' example',       start: 33, end: 41}
 * // ]
 *
 * // Omitting unneeded parts with null valueNames, and using escapeChar
 * str = '...{1}\\{{function(x,y){return y+x;}}';
 * XRegExp.matchRecursive(str, '{', '}', 'g', {
 *   valueNames: ['literal', null, 'value', null],
 *   escapeChar: '\\'
 * });
 * // -> [
 * // {name: 'literal', value: '...', start: 0, end: 3},
 * // {name: 'value',   value: '1',   start: 4, end: 5},
 * // {name: 'literal', value: '\\{', start: 6, end: 8},
 * // {name: 'value',   value: 'function(x,y){return y+x;}', start: 9, end: 35}
 * // ]
 *
 * // Sticky mode via flag y
 * str = '<1><<<2>>><3>4<5>';
 * XRegExp.matchRecursive(str, '<', '>', 'gy');
 * // -> ['1', '<<2>>', '3']
 */
    XRegExp.matchRecursive = function (str, left, right, flags, options) {
        flags = flags || "";
        options = options || {};
        var global = flags.indexOf("g") > -1,
            sticky = flags.indexOf("y") > -1,
            basicFlags = flags.replace(/y/g, ""), // Flag y controlled internally
            escapeChar = options.escapeChar,
            vN = options.valueNames,
            output = [],
            openTokens = 0,
            delimStart = 0,
            delimEnd = 0,
            lastOuterEnd = 0,
            outerStart,
            innerStart,
            leftMatch,
            rightMatch,
            esc;
        left = XRegExp(left, basicFlags);
        right = XRegExp(right, basicFlags);

        if (escapeChar) {
            if (escapeChar.length > 1) {
                throw new SyntaxError("can't use more than one escape character");
            }
            escapeChar = XRegExp.escape(escapeChar);
            // Using XRegExp.union safely rewrites backreferences in `left` and `right`
            esc = new RegExp(
                "(?:" + escapeChar + "[\\S\\s]|(?:(?!" + XRegExp.union([left, right]).source + ")[^" + escapeChar + "])+)+",
                flags.replace(/[^im]+/g, "") // Flags gy not needed here; flags nsx handled by XRegExp
            );
        }

        while (true) {
            // If using an escape character, advance to the delimiter's next starting position,
            // skipping any escaped characters in between
            if (escapeChar) {
                delimEnd += (XRegExp.exec(str, esc, delimEnd, "sticky") || [""])[0].length;
            }
            leftMatch = XRegExp.exec(str, left, delimEnd);
            rightMatch = XRegExp.exec(str, right, delimEnd);
            // Keep the leftmost match only
            if (leftMatch && rightMatch) {
                if (leftMatch.index <= rightMatch.index) {
                    rightMatch = null;
                } else {
                    leftMatch = null;
                }
            }
            /* Paths (LM:leftMatch, RM:rightMatch, OT:openTokens):
            LM | RM | OT | Result
            1  | 0  | 1  | loop
            1  | 0  | 0  | loop
            0  | 1  | 1  | loop
            0  | 1  | 0  | throw
            0  | 0  | 1  | throw
            0  | 0  | 0  | break
            * Doesn't include the sticky mode special case
            * Loop ends after the first completed match if `!global` */
            if (leftMatch || rightMatch) {
                delimStart = (leftMatch || rightMatch).index;
                delimEnd = delimStart + (leftMatch || rightMatch)[0].length;
            } else if (!openTokens) {
                break;
            }
            if (sticky && !openTokens && delimStart > lastOuterEnd) {
                break;
            }
            if (leftMatch) {
                if (!openTokens) {
                    outerStart = delimStart;
                    innerStart = delimEnd;
                }
                ++openTokens;
            } else if (rightMatch && openTokens) {
                if (!--openTokens) {
                    if (vN) {
                        if (vN[0] && outerStart > lastOuterEnd) {
                            output.push(row(vN[0], str.slice(lastOuterEnd, outerStart), lastOuterEnd, outerStart));
                        }
                        if (vN[1]) {
                            output.push(row(vN[1], str.slice(outerStart, innerStart), outerStart, innerStart));
                        }
                        if (vN[2]) {
                            output.push(row(vN[2], str.slice(innerStart, delimStart), innerStart, delimStart));
                        }
                        if (vN[3]) {
                            output.push(row(vN[3], str.slice(delimStart, delimEnd), delimStart, delimEnd));
                        }
                    } else {
                        output.push(str.slice(innerStart, delimStart));
                    }
                    lastOuterEnd = delimEnd;
                    if (!global) {
                        break;
                    }
                }
            } else {
                throw new Error("string contains unbalanced delimiters");
            }
            // If the delimiter matched an empty string, avoid an infinite loop
            if (delimStart === delimEnd) {
                ++delimEnd;
            }
        }

        if (global && !sticky && vN && vN[0] && str.length > lastOuterEnd) {
            output.push(row(vN[0], str.slice(lastOuterEnd), lastOuterEnd, str.length));
        }

        return output;
    };

}(XRegExp));


/***** build.js *****/

/*!
 * XRegExp.build v0.1.0
 * (c) 2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 * Inspired by RegExp.create by Lea Verou <http://lea.verou.me/>
 */

(function (XRegExp) {
    "use strict";

    var subparts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g,
        parts = XRegExp.union([/\({{([\w$]+)}}\)|{{([\w$]+)}}/, subparts], "g");

/**
 * Strips a leading `^` and trailing unescaped `$`, if both are present.
 * @private
 * @param {String} pattern Pattern to process.
 * @returns {String} Pattern with edge anchors removed.
 */
    function deanchor(pattern) {
        var startAnchor = /^(?:\(\?:\))?\^/, // Leading `^` or `(?:)^` (handles /x cruft)
            endAnchor = /\$(?:\(\?:\))?$/; // Trailing `$` or `$(?:)` (handles /x cruft)
        if (endAnchor.test(pattern.replace(/\\[\s\S]/g, ""))) { // Ensure trailing `$` isn't escaped
            return pattern.replace(startAnchor, "").replace(endAnchor, "");
        }
        return pattern;
    }

/**
 * Converts the provided value to an XRegExp.
 * @private
 * @param {String|RegExp} value Value to convert.
 * @returns {RegExp} XRegExp object with XRegExp syntax applied.
 */
    function asXRegExp(value) {
        return XRegExp.isRegExp(value) ?
                (value.xregexp && !value.xregexp.isNative ? value : XRegExp(value.source)) :
                XRegExp(value);
    }

/**
 * Builds regexes using named subpatterns, for readability and pattern reuse. Backreferences in the
 * outer pattern and provided subpatterns are automatically renumbered to work correctly. Native
 * flags used by provided subpatterns are ignored in favor of the `flags` argument.
 * @memberOf XRegExp
 * @param {String} pattern XRegExp pattern using `{{name}}` for embedded subpatterns. Allows
 *   `({{name}})` as shorthand for `(?<name>{{name}})`. Patterns cannot be embedded within
 *   character classes.
 * @param {Object} subs Lookup object for named subpatterns. Values can be strings or regexes. A
 *   leading `^` and trailing unescaped `$` are stripped from subpatterns, if both are present.
 * @param {String} [flags] Any combination of XRegExp flags.
 * @returns {RegExp} Regex with interpolated subpatterns.
 * @example
 *
 * var time = XRegExp.build('(?x)^ {{hours}} ({{minutes}}) $', {
 *   hours: XRegExp.build('{{h12}} : | {{h24}}', {
 *     h12: /1[0-2]|0?[1-9]/,
 *     h24: /2[0-3]|[01][0-9]/
 *   }, 'x'),
 *   minutes: /^[0-5][0-9]$/
 * });
 * time.test('10:59'); // -> true
 * XRegExp.exec('10:59', time).minutes; // -> '59'
 */
    XRegExp.build = function (pattern, subs, flags) {
        var inlineFlags = /^\(\?([\w$]+)\)/.exec(pattern),
            data = {},
            numCaps = 0, // Caps is short for captures
            numPriorCaps,
            numOuterCaps = 0,
            outerCapsMap = [0],
            outerCapNames,
            sub,
            p;

        // Add flags within a leading mode modifier to the overall pattern's flags
        if (inlineFlags) {
            flags = flags || "";
            inlineFlags[1].replace(/./g, function (flag) {
                flags += (flags.indexOf(flag) > -1 ? "" : flag); // Don't add duplicates
            });
        }

        for (p in subs) {
            if (subs.hasOwnProperty(p)) {
                // Passing to XRegExp enables entended syntax for subpatterns provided as strings
                // and ensures independent validity, lest an unescaped `(`, `)`, `[`, or trailing
                // `\` breaks the `(?:)` wrapper. For subpatterns provided as regexes, it dies on
                // octals and adds the `xregexp` property, for simplicity
                sub = asXRegExp(subs[p]);
                // Deanchoring allows embedding independently useful anchored regexes. If you
                // really need to keep your anchors, double them (i.e., `^^...$$`)
                data[p] = {pattern: deanchor(sub.source), names: sub.xregexp.captureNames || []};
            }
        }

        // Passing to XRegExp dies on octals and ensures the outer pattern is independently valid;
        // helps keep this simple. Named captures will be put back
        pattern = asXRegExp(pattern);
        outerCapNames = pattern.xregexp.captureNames || [];
        pattern = pattern.source.replace(parts, function ($0, $1, $2, $3, $4) {
            var subName = $1 || $2, capName, intro;
            if (subName) { // Named subpattern
                if (!data.hasOwnProperty(subName)) {
                    throw new ReferenceError("undefined property " + $0);
                }
                if ($1) { // Named subpattern was wrapped in a capturing group
                    capName = outerCapNames[numOuterCaps];
                    outerCapsMap[++numOuterCaps] = ++numCaps;
                    // If it's a named group, preserve the name. Otherwise, use the subpattern name
                    // as the capture name
                    intro = "(?<" + (capName || subName) + ">";
                } else {
                    intro = "(?:";
                }
                numPriorCaps = numCaps;
                return intro + data[subName].pattern.replace(subparts, function (match, paren, backref) {
                    if (paren) { // Capturing group
                        capName = data[subName].names[numCaps - numPriorCaps];
                        ++numCaps;
                        if (capName) { // If the current capture has a name, preserve the name
                            return "(?<" + capName + ">";
                        }
                    } else if (backref) { // Backreference
                        return "\\" + (+backref + numPriorCaps); // Rewrite the backreference
                    }
                    return match;
                }) + ")";
            }
            if ($3) { // Capturing group
                capName = outerCapNames[numOuterCaps];
                outerCapsMap[++numOuterCaps] = ++numCaps;
                if (capName) { // If the current capture has a name, preserve the name
                    return "(?<" + capName + ">";
                }
            } else if ($4) { // Backreference
                return "\\" + outerCapsMap[+$4]; // Rewrite the backreference
            }
            return $0;
        });

        return XRegExp(pattern, flags);
    };

}(XRegExp));


/***** prototypes.js *****/

/*!
 * XRegExp Prototype Methods v1.0.0
 * (c) 2012 Steven Levithan <http://xregexp.com/>
 * MIT License
 */

/**
 * Adds a collection of methods to `XRegExp.prototype`. RegExp objects copied by XRegExp are also
 * augmented with any `XRegExp.prototype` methods. Hence, the following work equivalently:
 *
 * XRegExp('[a-z]', 'ig').xexec('abc');
 * XRegExp(/[a-z]/ig).xexec('abc');
 * XRegExp.globalize(/[a-z]/i).xexec('abc');
 */
(function (XRegExp) {
    "use strict";

/**
 * Copy properties of `b` to `a`.
 * @private
 * @param {Object} a Object that will receive new properties.
 * @param {Object} b Object whose properties will be copied.
 */
    function extend(a, b) {
        for (var p in b) {
            if (b.hasOwnProperty(p)) {
                a[p] = b[p];
            }
        }
        //return a;
    }

    extend(XRegExp.prototype, {

/**
 * Implicitly calls the regex's `test` method with the first value in the provided arguments array.
 * @memberOf XRegExp.prototype
 * @param {*} context Ignored. Accepted only for congruity with `Function.prototype.apply`.
 * @param {Array} args Array with the string to search as its first value.
 * @returns {Boolean} Whether the regex matched the provided value.
 * @example
 *
 * XRegExp('[a-z]').apply(null, ['abc']); // -> true
 */
        apply: function (context, args) {
            return this.test(args[0]);
        },

/**
 * Implicitly calls the regex's `test` method with the provided string.
 * @memberOf XRegExp.prototype
 * @param {*} context Ignored. Accepted only for congruity with `Function.prototype.call`.
 * @param {String} str String to search.
 * @returns {Boolean} Whether the regex matched the provided value.
 * @example
 *
 * XRegExp('[a-z]').call(null, 'abc'); // -> true
 */
        call: function (context, str) {
            return this.test(str);
        },

/**
 * Implicitly calls {@link #XRegExp.forEach}.
 * @memberOf XRegExp.prototype
 * @example
 *
 * XRegExp('\\d').forEach('1a2345', function (match, i) {
 *   if (i % 2) this.push(+match[0]);
 * }, []);
 * // -> [2, 4]
 */
        forEach: function (str, callback, context) {
            return XRegExp.forEach(str, this, callback, context);
        },

/**
 * Implicitly calls {@link #XRegExp.globalize}.
 * @memberOf XRegExp.prototype
 * @example
 *
 * var globalCopy = XRegExp('regex').globalize();
 * globalCopy.global; // -> true
 */
        globalize: function () {
            return XRegExp.globalize(this);
        },

/**
 * Implicitly calls {@link #XRegExp.exec}.
 * @memberOf XRegExp.prototype
 * @example
 *
 * var match = XRegExp('U\\+(?<hex>[0-9A-F]{4})').xexec('U+2620');
 * match.hex; // -> '2620'
 */
        xexec: function (str, pos, sticky) {
            return XRegExp.exec(str, this, pos, sticky);
        },

/**
 * Implicitly calls {@link #XRegExp.test}.
 * @memberOf XRegExp.prototype
 * @example
 *
 * XRegExp('c').xtest('abc'); // -> true
 */
        xtest: function (str, pos, sticky) {
            return XRegExp.test(str, this, pos, sticky);
        }

    });

}(XRegExp));

// TinyColor v0.9.15
// https://github.com/bgrins/TinyColor
// 2013-07-04, Brian Grinstead, MIT License
(function(root){function tinycolor(color,opts){if(color=color?color:"",opts=opts||{},"object"==typeof color&&color.hasOwnProperty("_tc_id"))return color;var rgb=inputToRGB(color),r=rgb.r,g=rgb.g,b=rgb.b,a=rgb.a,roundA=mathRound(100*a)/100,format=opts.format||rgb.format;return 1>r&&(r=mathRound(r)),1>g&&(g=mathRound(g)),1>b&&(b=mathRound(b)),{ok:rgb.ok,format:format,_tc_id:tinyCounter++,alpha:a,toHsv:function(){var hsv=rgbToHsv(r,g,b);return{h:360*hsv.h,s:hsv.s,v:hsv.v,a:a}},toHsvString:function(){var hsv=rgbToHsv(r,g,b),h=mathRound(360*hsv.h),s=mathRound(100*hsv.s),v=mathRound(100*hsv.v);return 1==a?"hsv("+h+", "+s+"%, "+v+"%)":"hsva("+h+", "+s+"%, "+v+"%, "+roundA+")"},toHsl:function(){var hsl=rgbToHsl(r,g,b);return{h:360*hsl.h,s:hsl.s,l:hsl.l,a:a}},toHslString:function(){var hsl=rgbToHsl(r,g,b),h=mathRound(360*hsl.h),s=mathRound(100*hsl.s),l=mathRound(100*hsl.l);return 1==a?"hsl("+h+", "+s+"%, "+l+"%)":"hsla("+h+", "+s+"%, "+l+"%, "+roundA+")"},toHex:function(allow3Char){return rgbToHex(r,g,b,allow3Char)},toHexString:function(allow3Char){return"#"+rgbToHex(r,g,b,allow3Char)},toRgb:function(){return{r:mathRound(r),g:mathRound(g),b:mathRound(b),a:a}},toRgbString:function(){return 1==a?"rgb("+mathRound(r)+", "+mathRound(g)+", "+mathRound(b)+")":"rgba("+mathRound(r)+", "+mathRound(g)+", "+mathRound(b)+", "+roundA+")"},toPercentageRgb:function(){return{r:mathRound(100*bound01(r,255))+"%",g:mathRound(100*bound01(g,255))+"%",b:mathRound(100*bound01(b,255))+"%",a:a}},toPercentageRgbString:function(){return 1==a?"rgb("+mathRound(100*bound01(r,255))+"%, "+mathRound(100*bound01(g,255))+"%, "+mathRound(100*bound01(b,255))+"%)":"rgba("+mathRound(100*bound01(r,255))+"%, "+mathRound(100*bound01(g,255))+"%, "+mathRound(100*bound01(b,255))+"%, "+roundA+")"},toName:function(){return 0===a?"transparent":hexNames[rgbToHex(r,g,b,!0)]||!1},toFilter:function(secondColor){var hex=rgbToHex(r,g,b),secondHex=hex,alphaHex=Math.round(255*parseFloat(a)).toString(16),secondAlphaHex=alphaHex,gradientType=opts&&opts.gradientType?"GradientType = 1, ":"";if(secondColor){var s=tinycolor(secondColor);secondHex=s.toHex(),secondAlphaHex=Math.round(255*parseFloat(s.alpha)).toString(16)}return"progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr=#"+pad2(alphaHex)+hex+",endColorstr=#"+pad2(secondAlphaHex)+secondHex+")"},toString:function(format){var formatSet=!!format;format=format||this.format;var formattedString=!1,hasAlphaAndFormatNotSet=!formatSet&&1>a&&a>0,formatWithAlpha=hasAlphaAndFormatNotSet&&("hex"===format||"hex6"===format||"hex3"===format||"name"===format);return"rgb"===format&&(formattedString=this.toRgbString()),"prgb"===format&&(formattedString=this.toPercentageRgbString()),("hex"===format||"hex6"===format)&&(formattedString=this.toHexString()),"hex3"===format&&(formattedString=this.toHexString(!0)),"name"===format&&(formattedString=this.toName()),"hsl"===format&&(formattedString=this.toHslString()),"hsv"===format&&(formattedString=this.toHsvString()),formatWithAlpha?this.toRgbString():formattedString||this.toHexString()}}}function inputToRGB(color){var rgb={r:0,g:0,b:0},a=1,ok=!1,format=!1;return"string"==typeof color&&(color=stringInputToObject(color)),"object"==typeof color&&(color.hasOwnProperty("r")&&color.hasOwnProperty("g")&&color.hasOwnProperty("b")?(rgb=rgbToRgb(color.r,color.g,color.b),ok=!0,format="%"===(color.r+"").substr(-1)?"prgb":"rgb"):color.hasOwnProperty("h")&&color.hasOwnProperty("s")&&color.hasOwnProperty("v")?(color.s=convertToPercentage(color.s),color.v=convertToPercentage(color.v),rgb=hsvToRgb(color.h,color.s,color.v),ok=!0,format="hsv"):color.hasOwnProperty("h")&&color.hasOwnProperty("s")&&color.hasOwnProperty("l")&&(color.s=convertToPercentage(color.s),color.l=convertToPercentage(color.l),rgb=hslToRgb(color.h,color.s,color.l),ok=!0,format="hsl"),color.hasOwnProperty("a")&&(a=color.a)),a=parseFloat(a),(isNaN(a)||0>a||a>1)&&(a=1),{ok:ok,format:color.format||format,r:mathMin(255,mathMax(rgb.r,0)),g:mathMin(255,mathMax(rgb.g,0)),b:mathMin(255,mathMax(rgb.b,0)),a:a}}function rgbToRgb(r,g,b){return{r:255*bound01(r,255),g:255*bound01(g,255),b:255*bound01(b,255)}}function rgbToHsl(r,g,b){r=bound01(r,255),g=bound01(g,255),b=bound01(b,255);var h,s,max=mathMax(r,g,b),min=mathMin(r,g,b),l=(max+min)/2;if(max==min)h=s=0;else{var d=max-min;switch(s=l>.5?d/(2-max-min):d/(max+min),max){case r:h=(g-b)/d+(b>g?6:0);break;case g:h=(b-r)/d+2;break;case b:h=(r-g)/d+4}h/=6}return{h:h,s:s,l:l}}function hslToRgb(h,s,l){function hue2rgb(p,q,t){return 0>t&&(t+=1),t>1&&(t-=1),1/6>t?p+6*(q-p)*t:.5>t?q:2/3>t?p+6*(q-p)*(2/3-t):p}var r,g,b;if(h=bound01(h,360),s=bound01(s,100),l=bound01(l,100),0===s)r=g=b=l;else{var q=.5>l?l*(1+s):l+s-l*s,p=2*l-q;r=hue2rgb(p,q,h+1/3),g=hue2rgb(p,q,h),b=hue2rgb(p,q,h-1/3)}return{r:255*r,g:255*g,b:255*b}}function rgbToHsv(r,g,b){r=bound01(r,255),g=bound01(g,255),b=bound01(b,255);var h,s,max=mathMax(r,g,b),min=mathMin(r,g,b),v=max,d=max-min;if(s=0===max?0:d/max,max==min)h=0;else{switch(max){case r:h=(g-b)/d+(b>g?6:0);break;case g:h=(b-r)/d+2;break;case b:h=(r-g)/d+4}h/=6}return{h:h,s:s,v:v}}function hsvToRgb(h,s,v){h=6*bound01(h,360),s=bound01(s,100),v=bound01(v,100);var i=math.floor(h),f=h-i,p=v*(1-s),q=v*(1-f*s),t=v*(1-(1-f)*s),mod=i%6,r=[v,q,p,p,t,v][mod],g=[t,v,v,q,p,p][mod],b=[p,p,t,v,v,q][mod];return{r:255*r,g:255*g,b:255*b}}function rgbToHex(r,g,b,allow3Char){var hex=[pad2(mathRound(r).toString(16)),pad2(mathRound(g).toString(16)),pad2(mathRound(b).toString(16))];return allow3Char&&hex[0].charAt(0)==hex[0].charAt(1)&&hex[1].charAt(0)==hex[1].charAt(1)&&hex[2].charAt(0)==hex[2].charAt(1)?hex[0].charAt(0)+hex[1].charAt(0)+hex[2].charAt(0):hex.join("")}function flip(o){var flipped={};for(var i in o)o.hasOwnProperty(i)&&(flipped[o[i]]=i);return flipped}function bound01(n,max){isOnePointZero(n)&&(n="100%");var processPercent=isPercentage(n);return n=mathMin(max,mathMax(0,parseFloat(n))),processPercent&&(n=parseInt(n*max,10)/100),1e-6>math.abs(n-max)?1:n%max/parseFloat(max)}function clamp01(val){return mathMin(1,mathMax(0,val))}function parseHex(val){return parseInt(val,16)}function isOnePointZero(n){return"string"==typeof n&&-1!=n.indexOf(".")&&1===parseFloat(n)}function isPercentage(n){return"string"==typeof n&&-1!=n.indexOf("%")}function pad2(c){return 1==c.length?"0"+c:""+c}function convertToPercentage(n){return 1>=n&&(n=100*n+"%"),n}function stringInputToObject(color){color=color.replace(trimLeft,"").replace(trimRight,"").toLowerCase();var named=!1;if(names[color])color=names[color],named=!0;else if("transparent"==color)return{r:0,g:0,b:0,a:0,format:"name"};var match;return(match=matchers.rgb.exec(color))?{r:match[1],g:match[2],b:match[3]}:(match=matchers.rgba.exec(color))?{r:match[1],g:match[2],b:match[3],a:match[4]}:(match=matchers.hsl.exec(color))?{h:match[1],s:match[2],l:match[3]}:(match=matchers.hsla.exec(color))?{h:match[1],s:match[2],l:match[3],a:match[4]}:(match=matchers.hsv.exec(color))?{h:match[1],s:match[2],v:match[3]}:(match=matchers.hex6.exec(color))?{r:parseHex(match[1]),g:parseHex(match[2]),b:parseHex(match[3]),format:named?"name":"hex"}:(match=matchers.hex3.exec(color))?{r:parseHex(match[1]+""+match[1]),g:parseHex(match[2]+""+match[2]),b:parseHex(match[3]+""+match[3]),format:named?"name":"hex"}:!1}var trimLeft=/^[\s,#]+/,trimRight=/\s+$/,tinyCounter=0,math=Math,mathRound=math.round,mathMin=math.min,mathMax=math.max,mathRandom=math.random;tinycolor.fromRatio=function(color,opts){if("object"==typeof color){var newColor={};for(var i in color)color.hasOwnProperty(i)&&(newColor[i]="a"===i?color[i]:convertToPercentage(color[i]));color=newColor}return tinycolor(color,opts)},tinycolor.equals=function(color1,color2){return color1&&color2?tinycolor(color1).toRgbString()==tinycolor(color2).toRgbString():!1},tinycolor.random=function(){return tinycolor.fromRatio({r:mathRandom(),g:mathRandom(),b:mathRandom()})},tinycolor.desaturate=function(color,amount){amount=0===amount?0:amount||10;var hsl=tinycolor(color).toHsl();return hsl.s-=amount/100,hsl.s=clamp01(hsl.s),tinycolor(hsl)},tinycolor.saturate=function(color,amount){amount=0===amount?0:amount||10;var hsl=tinycolor(color).toHsl();return hsl.s+=amount/100,hsl.s=clamp01(hsl.s),tinycolor(hsl)},tinycolor.greyscale=function(color){return tinycolor.desaturate(color,100)},tinycolor.lighten=function(color,amount){amount=0===amount?0:amount||10;var hsl=tinycolor(color).toHsl();return hsl.l+=amount/100,hsl.l=clamp01(hsl.l),tinycolor(hsl)},tinycolor.darken=function(color,amount){amount=0===amount?0:amount||10;var hsl=tinycolor(color).toHsl();return hsl.l-=amount/100,hsl.l=clamp01(hsl.l),tinycolor(hsl)},tinycolor.complement=function(color){var hsl=tinycolor(color).toHsl();return hsl.h=(hsl.h+180)%360,tinycolor(hsl)},tinycolor.triad=function(color){var hsl=tinycolor(color).toHsl(),h=hsl.h;return[tinycolor(color),tinycolor({h:(h+120)%360,s:hsl.s,l:hsl.l}),tinycolor({h:(h+240)%360,s:hsl.s,l:hsl.l})]},tinycolor.tetrad=function(color){var hsl=tinycolor(color).toHsl(),h=hsl.h;return[tinycolor(color),tinycolor({h:(h+90)%360,s:hsl.s,l:hsl.l}),tinycolor({h:(h+180)%360,s:hsl.s,l:hsl.l}),tinycolor({h:(h+270)%360,s:hsl.s,l:hsl.l})]},tinycolor.splitcomplement=function(color){var hsl=tinycolor(color).toHsl(),h=hsl.h;return[tinycolor(color),tinycolor({h:(h+72)%360,s:hsl.s,l:hsl.l}),tinycolor({h:(h+216)%360,s:hsl.s,l:hsl.l})]},tinycolor.analogous=function(color,results,slices){results=results||6,slices=slices||30;var hsl=tinycolor(color).toHsl(),part=360/slices,ret=[tinycolor(color)];for(hsl.h=(hsl.h-(part*results>>1)+720)%360;--results;)hsl.h=(hsl.h+part)%360,ret.push(tinycolor(hsl));return ret},tinycolor.monochromatic=function(color,results){results=results||6;for(var hsv=tinycolor(color).toHsv(),h=hsv.h,s=hsv.s,v=hsv.v,ret=[],modification=1/results;results--;)ret.push(tinycolor({h:h,s:s,v:v})),v=(v+modification)%1;return ret},tinycolor.readability=function(color1,color2){var a=tinycolor(color1).toRgb(),b=tinycolor(color2).toRgb(),brightnessA=(299*a.r+587*a.g+114*a.b)/1e3,brightnessB=(299*b.r+587*b.g+114*b.b)/1e3,colorDiff=Math.max(a.r,b.r)-Math.min(a.r,b.r)+Math.max(a.g,b.g)-Math.min(a.g,b.g)+Math.max(a.b,b.b)-Math.min(a.b,b.b);return{brightness:Math.abs(brightnessA-brightnessB),color:colorDiff}},tinycolor.readable=function(color1,color2){var readability=tinycolor.readability(color1,color2);return readability.brightness>125&&readability.color>500},tinycolor.mostReadable=function(baseColor,colorList){for(var bestColor=null,bestScore=0,bestIsReadable=!1,i=0;colorList.length>i;i++){var readability=tinycolor.readability(baseColor,colorList[i]),readable=readability.brightness>125&&readability.color>500,score=3*(readability.brightness/125)+readability.color/500;(readable&&!bestIsReadable||readable&&bestIsReadable&&score>bestScore||!readable&&!bestIsReadable&&score>bestScore)&&(bestIsReadable=readable,bestScore=score,bestColor=tinycolor(colorList[i]))}return bestColor};var names=tinycolor.names={aliceblue:"f0f8ff",antiquewhite:"faebd7",aqua:"0ff",aquamarine:"7fffd4",azure:"f0ffff",beige:"f5f5dc",bisque:"ffe4c4",black:"000",blanchedalmond:"ffebcd",blue:"00f",blueviolet:"8a2be2",brown:"a52a2a",burlywood:"deb887",burntsienna:"ea7e5d",cadetblue:"5f9ea0",chartreuse:"7fff00",chocolate:"d2691e",coral:"ff7f50",cornflowerblue:"6495ed",cornsilk:"fff8dc",crimson:"dc143c",cyan:"0ff",darkblue:"00008b",darkcyan:"008b8b",darkgoldenrod:"b8860b",darkgray:"a9a9a9",darkgreen:"006400",darkgrey:"a9a9a9",darkkhaki:"bdb76b",darkmagenta:"8b008b",darkolivegreen:"556b2f",darkorange:"ff8c00",darkorchid:"9932cc",darkred:"8b0000",darksalmon:"e9967a",darkseagreen:"8fbc8f",darkslateblue:"483d8b",darkslategray:"2f4f4f",darkslategrey:"2f4f4f",darkturquoise:"00ced1",darkviolet:"9400d3",deeppink:"ff1493",deepskyblue:"00bfff",dimgray:"696969",dimgrey:"696969",dodgerblue:"1e90ff",firebrick:"b22222",floralwhite:"fffaf0",forestgreen:"228b22",fuchsia:"f0f",gainsboro:"dcdcdc",ghostwhite:"f8f8ff",gold:"ffd700",goldenrod:"daa520",gray:"808080",green:"008000",greenyellow:"adff2f",grey:"808080",honeydew:"f0fff0",hotpink:"ff69b4",indianred:"cd5c5c",indigo:"4b0082",ivory:"fffff0",khaki:"f0e68c",lavender:"e6e6fa",lavenderblush:"fff0f5",lawngreen:"7cfc00",lemonchiffon:"fffacd",lightblue:"add8e6",lightcoral:"f08080",lightcyan:"e0ffff",lightgoldenrodyellow:"fafad2",lightgray:"d3d3d3",lightgreen:"90ee90",lightgrey:"d3d3d3",lightpink:"ffb6c1",lightsalmon:"ffa07a",lightseagreen:"20b2aa",lightskyblue:"87cefa",lightslategray:"789",lightslategrey:"789",lightsteelblue:"b0c4de",lightyellow:"ffffe0",lime:"0f0",limegreen:"32cd32",linen:"faf0e6",magenta:"f0f",maroon:"800000",mediumaquamarine:"66cdaa",mediumblue:"0000cd",mediumorchid:"ba55d3",mediumpurple:"9370db",mediumseagreen:"3cb371",mediumslateblue:"7b68ee",mediumspringgreen:"00fa9a",mediumturquoise:"48d1cc",mediumvioletred:"c71585",midnightblue:"191970",mintcream:"f5fffa",mistyrose:"ffe4e1",moccasin:"ffe4b5",navajowhite:"ffdead",navy:"000080",oldlace:"fdf5e6",olive:"808000",olivedrab:"6b8e23",orange:"ffa500",orangered:"ff4500",orchid:"da70d6",palegoldenrod:"eee8aa",palegreen:"98fb98",paleturquoise:"afeeee",palevioletred:"db7093",papayawhip:"ffefd5",peachpuff:"ffdab9",peru:"cd853f",pink:"ffc0cb",plum:"dda0dd",powderblue:"b0e0e6",purple:"800080",red:"f00",rosybrown:"bc8f8f",royalblue:"4169e1",saddlebrown:"8b4513",salmon:"fa8072",sandybrown:"f4a460",seagreen:"2e8b57",seashell:"fff5ee",sienna:"a0522d",silver:"c0c0c0",skyblue:"87ceeb",slateblue:"6a5acd",slategray:"708090",slategrey:"708090",snow:"fffafa",springgreen:"00ff7f",steelblue:"4682b4",tan:"d2b48c",teal:"008080",thistle:"d8bfd8",tomato:"ff6347",turquoise:"40e0d0",violet:"ee82ee",wheat:"f5deb3",white:"fff",whitesmoke:"f5f5f5",yellow:"ff0",yellowgreen:"9acd32"},hexNames=tinycolor.hexNames=flip(names),matchers=function(){var CSS_INTEGER="[-\\+]?\\d+%?",CSS_NUMBER="[-\\+]?\\d*\\.\\d+%?",CSS_UNIT="(?:"+CSS_NUMBER+")|(?:"+CSS_INTEGER+")",PERMISSIVE_MATCH3="[\\s|\\(]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")\\s*\\)?",PERMISSIVE_MATCH4="[\\s|\\(]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")[,|\\s]+("+CSS_UNIT+")\\s*\\)?";return{rgb:RegExp("rgb"+PERMISSIVE_MATCH3),rgba:RegExp("rgba"+PERMISSIVE_MATCH4),hsl:RegExp("hsl"+PERMISSIVE_MATCH3),hsla:RegExp("hsla"+PERMISSIVE_MATCH4),hsv:RegExp("hsv"+PERMISSIVE_MATCH3),hex3:/^([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex6:/^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/}}();"undefined"!=typeof module&&module.exports?module.exports=tinycolor:"undefined"!=typeof define?define(function(){return tinycolor}):root.tinycolor=tinycolor})(this);
/*
    * Pick-a-Color JS v1.2.3
    * Copyright 2013 Lauren Sperber and Broadstreet Ads
    * https://github.com/lauren/pick-a-color/blob/master/LICENSE
*/
!function(o){"use strict";o.fn.pickAColor=function(t){void 0===t.touchOnlyMode&&(t.touchOnlyMode=!1);var e="ontouchstart"in window&&t.touchOnlyMode,a=(parseInt(o(window).width(),10)<767?!0:!1,"localStorage"in window&&null!==window.localStorage&&"object"==typeof JSON),n=document.all&&!window.atob,r=e?"touchstart.pickAColor":"mousedown.pickAColor",s=e?"touchmove.pickAColor":"mousemove.pickAColor",i=e?"touchend.pickAColor":"mouseup.pickAColor",l=e?"touchend.pickAColor":"click.pickAColor",d="dragging.pickAColor",c="endDrag.pickAColor",p=o.extend({showSpectrum:!0,showSavedColors:!0,saveColorsPerElement:!1,fadeMenuToggle:!0,showAdvanced:!0,showBasicColors:!0,showHexInput:!0,allowBlank:!1,inlineDropdown:!1,basicColors:{white:"fff",red:"f00",orange:"f60",yellow:"ff0",green:"008000",blue:"00f",purple:"800080",black:"000"}},t);p.showAdvanced||p.showBasicColors||(p.showBasicColors=!0);var u=p.showSavedColors&&p.showAdvanced||p.showBasicColors&&p.showSavedColors||p.showBasicColors&&p.showAdvanced,h=function(){var t=o("<div>").addClass("input-group-btn"),e=o("<button type='button'>").addClass("btn btn-default color-dropdown dropdown-toggle"),a=o("<span>").addClass("color-preview current-color"),r=o("<span>").addClass("caret"),s=o("<div>").addClass("color-menu dropdown-menu");if(p.inlineDropdown&&s.addClass("color-menu--inline"),p.showHexInput||(e.addClass("no-hex"),s.addClass("no-hex")),t.append(e.append(a).append(r)),u||p.showSpectrum||s.addClass("small"),u){var i=o("<div>").addClass("color-menu-tabs"),l=p.showBasicColors?"savedColors-tab tab":"savedColors-tab tab tab-active";p.showBasicColors&&i.append(o("<span>").addClass("basicColors-tab tab tab-active").append(o("<a>").text("Basic Colors"))),p.showSavedColors&&i.append(o("<span>").addClass(l).append(o("<a>").text("Saved Colors"))),p.showAdvanced&&i.append(o("<span>").addClass("advanced-tab tab").append(o("<a>").text("Advanced"))),s.append(i)}if(p.showBasicColors){var d=o("<div>").addClass("basicColors-content active-content");p.showSpectrum&&d.append(o("<h6>").addClass("color-menu-instructions").text("Tap spectrum or drag band to change color"));var c=o("<ul>").addClass("basic-colors-list");o.each(p.basicColors,function(t,e){var a=o("<li>").addClass("color-item"),r=o("<a>").addClass(t+" color-link"),s=o("<span>").addClass("color-preview "+t),i=o("<span>").addClass("color-label").text(t);if(r.append(s,i),s.append(),"#"!==e[0]&&(e="#"+e),s.css("background-color",e),p.showSpectrum){var l=o("<span>").addClass("color-box spectrum-"+t);n&&o.each([0,1],function(a){"fff"!==e&&"000"!==t&&l.append(o("<span>").addClass(t+"-spectrum-"+a+" ie-spectrum"))});var d=o("<span>").addClass("highlight-band");o.each([0,1,2],function(){d.append(o("<span>").addClass("highlight-band-stripe"))}),r.append(l.append(d))}c.append(a.append(r))}),s.append(d.append(c))}if(p.showSavedColors){var h=p.showBasicColors?"inactive-content":"active-content",g=o("<div>").addClass("savedColors-content").addClass(h);g.append(o("<p>").addClass("saved-colors-instructions").text("Type in a color or use the spectrums to lighten or darken an existing color.")),s.append(g)}if(p.showAdvanced){var v=p.showBasicColors||p.showSavedColors?"inactive-content":"active-content",f=o("<div>").addClass("advanced-content").addClass(v).append(o("<h6>").addClass("advanced-instructions").text("Tap spectrum or drag band to change color")),C=o("<ul>").addClass("advanced-list"),m=o("<li>").addClass("hue-item"),b=o("<span>").addClass("hue-text").text("Hue: ").append(o("<span>").addClass("hue-value").text("0")),w=o("<span>").addClass("color-box spectrum-hue");n&&o.each([0,1,2,3,4,5,6],function(t){w.append(o("<span>").addClass("hue-spectrum-"+t+" ie-spectrum hue"))});var S=o("<span>").addClass("highlight-band");o.each([0,1,2],function(){S.append(o("<span>").addClass("highlight-band-stripe"))}),C.append(m.append(b).append(w.append(S)));var y=o("<li>").addClass("lightness-item"),k=o("<span>").addClass("color-box spectrum-lightness"),x=o("<span>").addClass("lightness-text").text("Lightness: ").append(o("<span>").addClass("lightness-value").text("50%"));n&&o.each([0,1],function(t){k.append(o("<span>").addClass("lightness-spectrum-"+t+" ie-spectrum"))});var H=o("<span>").addClass("highlight-band");o.each([0,1,2],function(){H.append(o("<span>").addClass("highlight-band-stripe"))}),C.append(y.append(x).append(k.append(H)));var A=o("<li>").addClass("saturation-item"),B=o("<span>").addClass("color-box spectrum-saturation");n&&o.each([0,1],function(t){B.append(o("<span>").addClass("saturation-spectrum-"+t+" ie-spectrum"))});var M=o("<span>").addClass("highlight-band");o.each([0,1,2],function(){M.append(o("<span>").addClass("highlight-band-stripe"))});var I=o("<span>").addClass("saturation-text").text("Saturation: ").append(o("<span>").addClass("saturation-value").text("100%"));C.append(A.append(I).append(B.append(M)));var T=o("<li>").addClass("preview-item").append(o("<span>").addClass("preview-text").text("Preview")),P=o("<span>").addClass("color-preview advanced").append("<button class='color-select btn btn-mini advanced' type='button'>Select</button>");C.append(T.append(P)),s.append(f.append(C))}return t.append(s),t},g={},v={rowsInDropdown:8,maxColsInDropdown:2};if(p.showSavedColors){var f=[];if(a&&localStorage.allSavedColors)f=JSON.parse(localStorage.allSavedColors);else if(document.cookie.match("pickAColorSavedColors-allSavedColors=")){var C=document.cookie.split(";");o.each(C,function(o){C[o].match("pickAColorSavedColors-allSavedColors=")&&(f=C[o].split("=")[1].split(","))})}}var m={initialize:function(t){var e,a,n=o(this);n.attr("name")||n.attr("name","pick-a-color-"+t),a=n.attr("name"),n.addClass("pick-a-color"),p.allowBlank?n.val().match(/^\s+$|^$/)||(g.defaultColor=tinycolor(n.val()).toHex(),g.typedColor=g.defaultColor,n.val(g.defaultColor)):(g.defaultColor=tinycolor(n.val()).toHex(),g.typedColor=g.defaultColor,n.val(g.defaultColor)),o(n).wrap('<div class="input-group pick-a-color-markup" id="'+a+'">'),e=o(n.parent()),p.showHexInput?e.prepend('<span class="hex-pound input-group-addon">#</span>').append(h()):e.append(h()),p.showHexInput||n.attr("type","hidden")},updatePreview:function(o){p.allowBlank?(g.typedColor=o.val().match(/^\s+$|^$/)?"":tinycolor(o.val()).toHex(),""===g.typedColor?o.siblings(".input-group-btn").find(".current-color").css("background","none"):o.siblings(".input-group-btn").find(".current-color").css("background-color","#"+g.typedColor)):(g.typedColor=tinycolor(o.val()).toHex(),o.siblings(".input-group-btn").find(".current-color").css("background-color","#"+g.typedColor))},pressPreviewButton:function(){var o=arguments[0].thisEvent;o.stopPropagation(),m.toggleDropdown(o.target)},openDropdown:function(t,a){o(".color-menu").each(function(){var t=o(this);if("block"===t.css("display")){var e=t.parents(".input-group-btn");m.closeDropdown(e,t)}}),p.fadeMenuToggle&&!e?o(a).fadeIn("fast"):o(a).show(),o(t).addClass("open")},closeDropdown:function(t,a){p.fadeMenuToggle&&!e?o(a).fadeOut("fast"):o(a).css("display","none"),o(t).removeClass("open")},closeDropdownIfOpen:function(){var o=arguments[0].button,t=arguments[0].menu;"block"===t.css("display")&&m.closeDropdown(o,t)},toggleDropdown:function(t){var e=o(t).parents(".pick-a-color-markup"),a=e.find("input"),n=e.find(".input-group-btn"),r=e.find(".color-menu");a.is(":disabled")||"none"!==r.css("display")?m.closeDropdown(n,r):m.openDropdown(n,r)},tabbable:function(){var t=o(this),e=t.parents(".pick-a-color-markup");t.click(function(){var t=o(this),a=t.attr("class").split(" ")[0].split("-")[0]+"-content",n=t.parents(".dropdown-menu").find("."+a);t.hasClass("tab-active")||(e.find(".tab-active").removeClass("tab-active"),e.find(".active-content").removeClass("active-content").addClass("inactive-content"),t.addClass("tab-active"),o(n).addClass("active-content").removeClass("inactive-content"))})},getColorMultiplier:function(t,a,n){var r="basic"===n?parseInt(o(".color-box").first().width(),10):parseInt(o(".advanced-list").find(".color-box").first().width(),10);0===r&&(r="basic"===n?e?160:200:e?160:300);var s=r/2,i=a/r;return"bidirectional"===t?.5>=i?(1-a/s)/2:-((a-s)/s)/2:"darkenRight"===t?-(i/2):i/2},modifyHSLLightness:function(o,t){var e=o;return e.l+=t,e.l=Math.min(Math.max(0,e.l),1),tinycolor(e).toHslString()},getMoveableArea:function(o){var t={},e=o.parent(),a=o.outerWidth(),n=e.width(),r=e.offset();return t.minX=r.left,t.maxX=n-a,t},moveHighlightBand:function(t,a,n){var r=o(".highlight-band").first().outerWidth(),s=.75*r,i=e?n.originalEvent.pageX:n.pageX,l=i-a.minX-s;l=Math.max(0,Math.min(l,a.maxX)),t.css("position","absolute"),t.css("left",l)},horizontallyDraggable:function(){o(this).on(r,function(t){t.preventDefault();var e=o(t.delegateTarget);e.css("cursor","-webkit-grabbing"),e.css("cursor","-moz-grabbing");var a=m.getMoveableArea(e);o(document).on(s,function(o){e.trigger(d),m.moveHighlightBand(e,a,o)}).on(i,function(t){o(document).off(s),o(document).off(d),e.css("cursor","-webkit-grab"),e.css("cursor","-moz-grab"),e.trigger(c),o(document).off(i)})}).on(i,function(t){t.stopPropagation(),o(document).off(s),o(document).off(d)})},modifyHighlightBand:function(o,t,e){var a={h:0,s:0,l:.05},n={h:0,s:0,l:.5},r=-t,s=o.find(".highlight-band-stripe"),i="lightenRight"===e?m.modifyHSLLightness(n,r):m.modifyHSLLightness(a,r);o.css("border-color",i),s.css("background-color",i)},calculateHighlightedColor:function(){var t,e,a,n,r,s,i,l,d=o(this),c=d.parent(),u=o(".highlight-band").first().outerWidth(),h=u/2,g=arguments[0].type;if("basic"===g){var v=c.attr("class").split("-")[2],f=p.basicColors[v];switch(e=tinycolor(f).toHsl(),f){case"fff":t="darkenRight";break;case"000":t="lightenRight";break;default:t="bidirectional"}}else{var C=d.parents(".advanced-list");n=arguments[0].hsl.s,i=C.find(".spectrum-hue"),a=arguments[0].hsl.h,s=C.find(".spectrum-saturation"),l=C.find(".lightness-value"),r=C.find(".color-preview"),e={h:arguments[0].hsl.h,l:.5,s:arguments[0].hsl.s},t="bidirectional"}var b=parseInt(d.css("left"),10)+h,w=m.getColorMultiplier(t,b,g),S=m.modifyHSLLightness(e,w),y="#"+tinycolor(S).toHex(),k=S.split("(")[1].split(")")[0].split(",")[2],x=parseInt(k.split("%")[0],10)/100;return"basic"===g?(c.siblings(".color-preview").css("background-color",y),c.prev(".color-label").replaceWith('<button class="color-select btn btn-mini" type="button">Select</button>'),"darkenRight"!==t&&m.modifyHighlightBand(d,w,t)):(r.css("background-color",y),l.text(k),m.updateSaturationStyles(s,a,x),m.updateHueStyles(i,n,x),m.modifyHighlightBand(o(".advanced-content .highlight-band"),w,t)),"basic"===g?tinycolor(S).toHex():x},updateSavedColorPreview:function(t){o.each(t,function(e){var a=o(t[e]),n=a.attr("class");a.find(".color-preview").css("background-color",n)})},updateSavedColorMarkup:function(t,e){if(e=e?e:f,p.showSavedColors&&e.length>0){p.saveColorsPerElement||(t=o(".savedColors-content"),e=f);var a=v.rowsInDropdown*v.maxColsInDropdown;e=e.slice(0,a);var n=o("<ul>").addClass("saved-color-col 0"),r=o("<ul>").addClass("saved-color-col 1");o.each(e,function(t,e){var a=o("<li>").addClass("color-item"),s=o("<a>").addClass(e);s.append(o("<span>").addClass("color-preview")),s.append(o("<span>").addClass("color-label").text(e)),a.append(s),t%2===0?n.append(a):r.append(a)}),t.html(n),t.append(r);var s=o(t).find("a");m.updateSavedColorPreview(s)}},setSavedColorsCookie:function(o,t){var e=new Date,a=31536e7,n=new Date(e.getTime()+a);n=n.toGMTString(),"undefined"==typeof t?document.cookie="pickAColorSavedColors-allSavedColors="+o+";expires="+n:document.cookie="pickAColorSavedColors-"+t+"="+o+"; expires="+n},saveColorsToLocalStorage:function(o,t){if(a)if("undefined"==typeof t)try{localStorage.allSavedColors=JSON.stringify(o)}catch(e){localStorage.clear()}else try{localStorage["pickAColorSavedColors-"+t]=JSON.stringify(o)}catch(e){localStorage.clear()}else m.setSavedColorsCookie(o,t)},removeFromArray:function(t,e){-1!==o.inArray(e,t)&&t.splice(o.inArray(e,t),1)},updateSavedColors:function(o,t,e){m.removeFromArray(t,o),t.unshift(o),m.saveColorsToLocalStorage(t,e)},addToSavedColors:function(o,t,e){if(p.showSavedColors&&void 0!==o)if("#"!=o[0]&&(o="#"+o),m.updateSavedColors(o,f),p.saveColorsPerElement){var a=t.colors,n=t.dataAttr;m.updateSavedColors(o,a,n),m.updateSavedColorMarkup(e,a)}else m.updateSavedColorMarkup(e,f)},selectFromBasicColors:function(){var t=o(this).find("span:first").css("background-color"),e=arguments[0].els,a=arguments[0].savedColorsInfo;t=tinycolor(t).toHex(),o(e.thisEl).val(t),o(e.thisEl).trigger("change"),m.updatePreview(e.thisEl),m.addToSavedColors(t,a,e.savedColorsContent),m.closeDropdown(e.colorPreviewButton,e.colorMenu)},tapSpectrum:function(){var t=arguments[0].thisEvent,a=arguments[0].savedColorsInfo,n=arguments[0].els,r=arguments[0].mostRecentClick;t.stopPropagation();var s=o(this).find(".highlight-band"),i=m.getMoveableArea(s);e?m.moveHighlightBand(s,i,r):m.moveHighlightBand(s,i,t);var l=m.calculateHighlightedColor.apply(s,[{type:"basic"}]);m.addToSavedColors(l,a,n.savedColorsContent),n.touchInstructions.html("Press 'select' to choose this color")},executeUnlessScrolled:function(){var t,a,n=arguments[0].thisFunction,s=arguments[0].theseArguments;o(this).on(r,function(e){t=o(window).scrollTop(),a=e}).on(l,function(r){var i=t-o(window).scrollTop();return e&&Math.abs(i)>0?!1:(s.thisEvent=r,s.mostRecentClick=a,n.apply(o(this),[s]),void 0)})},updateSaturationStyles:function(t,e,a){var r=(100*a).toString()+"%",s="#"+tinycolor("hsl("+e+",0%,"+r).toHex(),i="#"+tinycolor("hsl("+e+",50%,"+r).toHex(),l="#"+tinycolor("hsl("+e+",100%,"+r).toHex(),d="",c=(o.each(["-webkit-linear-gradient","-o-linear-gradient"],function(o,t){d+="background-image: "+t+"(left, "+s+" 0%, "+i+" 50%, "+l+" 100%);"}),"progid:DXImageTransform.Microsoft.gradient(startColorstr='"+s+"', endColorstr='"+i+"', GradientType=1)"),p="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+i+"', endColorstr='"+l+"', GradientType=1)";if(d="background-image: -moz-linear-gradient(left center, "+s+" 0%, "+i+" 50%, "+l+" 100%);background-image: linear-gradient(to right, "+s+" 0%, "+i+" 50%, "+l+" 100%); background-image: -webkit-gradient(linear, left top, right top,color-stop(0, "+s+"),color-stop(0.5, "+i+"),color-stop(1, "+l+"));"+d,n){var u=o(t).find(".saturation-spectrum-0"),h=o(t).find(".saturation-spectrum-1");u.css("filter",c),h.css("filter",p)}else t.attr("style",d)},updateLightnessStyles:function(t,e,a){var r=(100*a).toString()+"%",s="#"+tinycolor("hsl("+e+","+r+",100%)").toHex(),i="#"+tinycolor("hsl("+e+","+r+",50%)").toHex(),l="#"+tinycolor("hsl("+e+","+r+",0%)").toHex(),d="",c=(o.each(["-webkit-linear-gradient","-o-linear-gradient"],function(o,t){d+="background-image: "+t+"(left, "+s+" 0%, "+i+" 50%, "+l+" 100%);"}),"progid:DXImageTransform.Microsoft.gradient(startColorstr='"+s+"', endColorstr='"+i+"', GradientType=1)"),p="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+i+"', endColorstr='"+l+"', GradientType=1)";if(d="background-image: -moz-linear-gradient(left center, "+s+" 0%, "+i+" 50%, "+l+" 100%); background-image: linear-gradient(to right, "+s+" 0%, "+i+" 50%, "+l+" 100%); background-image: -webkit-gradient(linear, left top, right top, color-stop(0, "+s+"), color-stop(0.5, "+i+"), color-stop(1, "+l+")); "+d,n){var u=o(t).find(".lightness-spectrum-0"),h=o(t).find(".lightness-spectrum-1");u.css("filter",c),h.css("filter",p)}else t.attr("style",d)},updateHueStyles:function(t,e,a){var r=(100*e).toString()+"%",s=(100*a).toString()+"%",i="#"+tinycolor("hsl(0,"+r+","+s+")").toHex(),l="#"+tinycolor("hsl(60,"+r+","+s+")").toHex(),d="#"+tinycolor("hsl(120,"+r+","+s+")").toHex(),c="#"+tinycolor("hsl(180,"+r+","+s+")").toHex(),p="#"+tinycolor("hsl(240,"+r+","+s+")").toHex(),u="#"+tinycolor("hsl(300,"+r+","+s+")").toHex(),h="#"+tinycolor("hsl(0,"+r+","+s+")").toHex(),g="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+i+"', endColorstr='"+l+"', GradientType=1)",v="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+l+"', endColorstr='"+d+"', GradientType=1)",f="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+d+"', endColorstr='"+c+"', GradientType=1)",C="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+c+"', endColorstr='"+p+"', GradientType=1)",m="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+p+"', endColorstr='"+u+"', GradientType=1)",b="progid:DXImageTransform.Microsoft.gradient(startColorstr='"+u+"', endColorstr='"+h+"', GradientType=1)",w="";o.each(["-webkit-linear-gradient","-o-linear-gradient"],function(o,t){w+="background-image: "+t+"(left, "+i+" 0%, "+l+" 17%, "+d+" 24%, "+c+" 51%, "+p+" 68%, "+u+" 85%, "+h+" 100%);"});if(w+="background-image: -webkit-gradient(linear, left top, right top,color-stop(0%, "+i+"),color-stop(17%, "+l+"),color-stop(34%, "+d+"),color-stop(51%, "+c+"),color-stop(68%, "+p+"),color-stop(85%, "+u+"),color-stop(100%, "+h+"));background-image: linear-gradient(to right, "+i+" 0%, "+l+" 17%, "+d+" 24%,"+c+" 51%,"+p+" 68%,"+u+" 85%,"+h+" 100%); background-image: -moz-linear-gradient(left center, "+i+" 0%, "+l+" 17%, "+d+" 24%, "+c+" 51%, "+p+" 68%, "+u+" 85%, "+h+" 100%);",n){var S=o(t).find(".hue-spectrum-0"),y=o(t).find(".hue-spectrum-1"),k=o(t).find(".hue-spectrum-2"),x=o(t).find(".hue-spectrum-3"),H=o(t).find(".hue-spectrum-4"),A=o(t).find(".hue-spectrum-5");S.css("filter",g),y.css("filter",v),k.css("filter",f),x.css("filter",C),H.css("filter",m),A.css("filter",b)}else t.attr("style",w)},getHighlightedHue:function(){var t=o(this),a=t.outerWidth(),n=a/2,r=parseInt(t.css("left"),10)+n,s=t.parents(".advanced-list"),i=s.find(".color-preview"),l=s.find(".spectrum-lightness"),d=s.find(".spectrum-saturation"),c=parseInt(s.find(".color-box").first().width(),10),p=s.find(".hue-value"),u=arguments[0].l,h=arguments[0].s,g=(100*h).toString()+"%",v=(100*u).toString()+"%";0===c&&(c=e?160:300);var f=Math.floor(r/c*360),C="hsl("+f+","+g+","+v+")";return C="#"+tinycolor(C).toHex(),i.css("background-color",C),p.text(f),m.updateLightnessStyles(l,f,h),m.updateSaturationStyles(d,f,u),f},getHighlightedSaturation:function(){var t=o(this),a=t.outerWidth(),n=a/2,r=parseInt(t.css("left"),10)+n,s=t.parents(".advanced-list"),i=s.find(".color-preview"),l=s.find(".spectrum-lightness"),d=s.find(".spectrum-hue"),c=s.find(".saturation-value"),p=parseInt(s.find(".color-box").first().width(),10),u=arguments[0].l,h=(100*u).toString()+"%",g=arguments[0].h;0===p&&(p=e?160:300);var v=r/p,f=Math.round(100*v).toString()+"%",C="hsl("+g+","+f+","+h+")";return C="#"+tinycolor(C).toHex(),i.css("background-color",C),c.text(f),m.updateLightnessStyles(l,g,v),m.updateHueStyles(d,v,u),v},updateAdvancedInstructions:function(o){o.html("Press the color preview to choose this color")}};return this.each(function(t){m.initialize.apply(this,[t]);var e,n,r={thisEl:o(this),thisWrapper:o(this).parent(),colorTextInput:o(this).find("input"),colorMenuLinks:o(this).parent().find(".color-menu li a"),colorPreviewButton:o(this).parent().find(".input-group-btn"),colorMenu:o(this).parent().find(".color-menu"),colorSpectrums:o(this).parent().find(".color-box"),basicSpectrums:o(this).parent().find(".basicColors-content .color-box"),touchInstructions:o(this).parent().find(".color-menu-instructions"),advancedInstructions:o(this).parent().find(".advanced-instructions"),highlightBands:o(this).parent().find(".highlight-band"),basicHighlightBands:o(this).parent().find(".basicColors-content .highlight-band")};if(u&&(r.tabs=r.thisWrapper.find(".tab")),p.showSavedColors&&(r.savedColorsContent=r.thisWrapper.find(".savedColors-content"),p.saveColorsPerElement))if(n={colors:[],dataObj:o(this).data()},o.each(n.dataObj,function(o){n.dataAttr=o}),a&&localStorage["pickAColorSavedColors-"+n.dataAttr])n.colors=JSON.parse(localStorage["pickAColorSavedColors-"+n.dataAttr]);else if(document.cookie.match("pickAColorSavedColors-"+n.dataAttr))for(var s=document.cookie.split(";"),h=0;h<s.length;h++)s[h].match(n.dataAttr)&&(n.colors=s[h].split("=")[1].split(","));else n.colors=f;p.showAdvanced&&(e={h:0,s:1,l:.5},r.advancedSpectrums=r.thisWrapper.find(".advanced-list").find(".color-box"),r.advancedHighlightBands=r.thisWrapper.find(".advanced-list").find(".highlight-band"),r.hueSpectrum=r.thisWrapper.find(".spectrum-hue"),r.lightnessSpectrum=r.thisWrapper.find(".spectrum-lightness"),r.saturationSpectrum=r.thisWrapper.find(".spectrum-saturation"),r.hueHighlightBand=r.thisWrapper.find(".spectrum-hue .highlight-band"),r.lightnessHighlightBand=r.thisWrapper.find(".spectrum-lightness .highlight-band"),r.saturationHighlightBand=r.thisWrapper.find(".spectrum-saturation .highlight-band"),r.advancedPreview=r.thisWrapper.find(".advanced-content .color-preview")),m.addToSavedColors(g.defaultColor,n,r.savedColorsContent),m.updatePreview(r.thisEl),r.thisEl.focus(function(){var t=o(this);g.typedColor=t.val(),p.allowBlank||t.val(""),m.toggleDropdown(r.colorPreviewButton,r.ColorMenu)}).blur(function(){var t=o(this);g.newValue=t.val(),g.newValue.match(/^\s+$|^$/)?p.allowBlank||t.val(g.typedColor):(g.newValue=tinycolor(g.newValue).toHex(),t.val(g.newValue),m.addToSavedColors(g.newValue,n,r.savedColorsContent)),m.toggleDropdown(r.colorPreviewButton,r.ColorMenu),m.updatePreview(t)}),m.executeUnlessScrolled.apply(r.colorPreviewButton,[{thisFunction:m.pressPreviewButton,theseArguments:{}}]),m.executeUnlessScrolled.apply(o(document),[{thisFunction:m.closeDropdownIfOpen,theseArguments:{button:r.colorPreviewButton,menu:r.colorMenu}}]),r.colorMenu.on(l,function(o){o.stopPropagation()}),r.thisEl.on(l,function(o){o.stopPropagation()}),m.executeUnlessScrolled.apply(r.colorMenuLinks,[{thisFunction:m.selectFromBasicColors,theseArguments:{els:r,savedColorsInfo:n}}]),u&&m.tabbable.apply(r.tabs),(p.showSpectrum||p.showAdvanced)&&m.horizontallyDraggable.apply(r.highlightBands),p.showSpectrum&&(m.executeUnlessScrolled.apply(r.basicSpectrums,[{thisFunction:m.tapSpectrum,theseArguments:{savedColorsInfo:n,els:r}}]),o(r.basicHighlightBands).on(d,function(o){o.target;m.calculateHighlightedColor.apply(this,[{type:"basic"}])}).on(c,function(o){var t=o.delegateTarget,e=m.calculateHighlightedColor.apply(t,[{type:"basic"}]);m.addToSavedColors(e,n,r.savedColorsContent)})),p.showAdvanced&&(o(r.hueHighlightBand).on(d,function(o){e.h=m.getHighlightedHue.apply(this,[e])}),o(r.lightnessHighlightBand).on(d,function(){m.calculateHighlightedColor.apply(this,[{type:"advanced",hsl:e}])}).on(i,function(){e.l=m.calculateHighlightedColor.apply(this,[{type:"advanced",hsl:e}])}),o(r.saturationHighlightBand).on(d,function(){m.getHighlightedSaturation.apply(this,[e])}).on(c,function(){e.s=m.getHighlightedSaturation.apply(this,[e])}),o(r.advancedHighlightBand).on(c,function(){m.updateAdvancedInstructions(r.advancedInstructions)}),o(r.lightnessSpectrum).click(function(t){t.stopPropagation();var a=o(this).find(".highlight-band"),n=m.getMoveableArea(a);m.moveHighlightBand(a,n,t),e.l=m.calculateHighlightedColor.apply(a,[{type:"advanced",hsl:e}])}),o(r.hueSpectrum).click(function(t){t.stopPropagation();var a=o(this).find(".highlight-band"),n=m.getMoveableArea(a);m.moveHighlightBand(a,n,t),e.h=m.getHighlightedHue.apply(a,[e])}),o(r.saturationSpectrum).click(function(t){t.stopPropagation();var a=o(this).find(".highlight-band"),n=m.getMoveableArea(a);m.moveHighlightBand(a,n,t),e.s=m.getHighlightedSaturation.apply(a,[e])}),o(r.advancedSpectrums).click(function(){m.updateAdvancedInstructions(r.advancedInstructions)}),o(r.advancedPreview).click(function(){var t=tinycolor(o(this).css("background-color")).toHex();o(r.thisEl).val(t),o(r.thisEl).trigger("change"),m.updatePreview(r.thisEl),m.addToSavedColors(t,n,r.savedColorsContent),m.closeDropdown(r.colorPreviewButton,r.colorMenu)})),p.showSavedColors&&(o(r.savedColorsContent).click(function(t){var e=o(t.target);if(e.is("SPAN")||e.is("A")){var a=e.is("SPAN")?e.parent().attr("class").split("#")[1]:e.attr("class").split("#")[1];o(r.thisEl).val(a),o(r.thisEl).trigger("change"),m.updatePreview(r.thisEl),m.closeDropdown(r.colorPreviewButton,r.colorMenu),m.addToSavedColors(a,n,r.savedColorsContent)}}),p.saveColorsPerElement?p.saveColorsPerElement&&m.updateSavedColorMarkup(r.savedColorsContent,n.colors):m.updateSavedColorMarkup(r.savedColorsContent,f))})}}(jQuery);
/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

window.Form = window.Form || {};

Form.rte = Form.rte || {};

(function (ns) {

    var locale = "en";

    var I18n = ns.I18n = {};

    I18n.setLocale = function (value) {
        if (value) {
            if (value.indexOf("-") > -1) {
                var splitLocale = value.split("-");
                value = splitLocale[0].toLowerCase();
                if (splitLocale.length > 1) {
                    value += splitLocale[1].toUpperCase();  // if locale has country include that
                }
            }
            locale = value;
        }
    };

    I18n.get = function (str, snippets) {
        if (!str) {
            return "";
        }
        var localeFile = I18n[locale] || I18n.en;
        var strings = localeFile.strings || {};
        if (strings.hasOwnProperty(str)) {
            str = strings[str];
        }
        if (snippets && snippets.length > 0) {
            var pattern = /{(\d+)}/g;
            var result = pattern.exec(str);
            while (result) {
                str = str.replace(result[0], snippets[result[1]]);
                result = pattern.exec(str);
            }
        }
        return str;
    };
})(Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var en = I18n.en = {};

    en.strings = {
        "Undo" : "Undo",
        "Redo" : "Redo",
        "Bold" : "Bold",
        "Italic" : "Italic",
        "Underline" : "Underline",
        "Super-script" : "Super-script",
        "Sub-script" : "Sub-script",
        "Text Color" : "Text Color",
        "Highlight Color" : "Highlight Color",
        "Font Family" : "Font Family",
        "Font Size" : "Font Size",
        "Line Height" : "Line Height",
        "Letter Spacing" : "Letter Spacing",
        "Paragraph Format" : "Paragraph Format",
        "Justify Left" : "Justify Left",
        "Justify Center" : "Justify Center",
        "Justify Full" : "Justify Full",
        "Justify Right" : "Justify Right",
        "Margin Left" : "Margin Left",
        "Margin Right" : "Margin Right",
        "Margin Top" : "Margin Top",
        "Margin Bottom" : "Margin Bottom",
        "Bulleted List" : "Bulleted List",
        "Numbered List" : "Numbered List",
        "Upper-case Alphabet List" : "Upper-case Alphabet List",
        "Lower-case Alphabet List" : "Lower-case Alphabet List",
        "Upper-case Roman List" : "Upper-case Roman List",
        "Lower-case Roman List" : "Lower-case Roman List",
        "Indent" : "Indent",
        "Outdent" : "Outdent",
        "Find & Replace" : "Find & Replace",
        "Insert Link" : "Insert Link",
        "Find" : "Find",
        "Replace" : "Replace",
        "Replace all" : "Replace all",
        "Match case" : "Match case",
        "Whole word" : "Whole word",
        "Reg Ex" : "Reg Ex",
        "Info" : "Info",
        "Reached end of module." : "Reached end of module.",
        "Match Not Found" : "Match Not Found",
        "{0} matches replaced" : "{0} matches replaced",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "None",
        "Header 1" : "Header 1",
        "Header 2" : "Header 2",
        "Header 3" : "Header 3",
        "Header 4" : "Header 4",
        "Header 5" : "Header 5",
        "Header 6" : "Header 6",
        "Select" : "Select",
        "Basic View" : "Basic View",
        "FullScreen" : "FullScreen",
        "Expand" : "Expand",
        "Collapse" : "Collapse",
        "List Type" : "List Type",
        "URL" : "URL",
        "Alt Text" : "Alt Text",
        "Open in new page" : "Open in new page"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var de = I18n.de = {};

    de.strings = {
        "Undo" : "Rückgängig",
        "Redo" : "Wiederholen",
        "Bold" : "Fett",
        "Italic" : "Kursiv",
        "Underline" : "Unterstrichen",
        "Super-script" : "Hochgestellt",
        "Sub-script" : "Tiefgestellt",
        "Text Color" : "Textfarbe",
        "Highlight Color" : "Hervorhebungsfarbe",
        "Font Family" : "Schriftfamilie",
        "Font Size" : "Schriftgrad",
        "Line Height" : "Zeilenhöhe",
        "Letter Spacing" : "Buchstabenabstand",
        "Paragraph Format" : "Absatzformat",
        "Justify Left" : "Links ausrichten",
        "Justify Center" : "Zentriert ausrichten",
        "Justify Full" : "Blocksatz",
        "Justify Right" : "Rechts ausrichten",
        "Margin Left" : "Rand links",
        "Margin Right" : "Rand rechts",
        "Margin Top" : "Rand oben",
        "Margin Bottom" : "Rand unten",
        "Bulleted List" : "Liste mit Aufzählungszeichen",
        "Numbered List" : "Nummerierte Liste",
        "Upper-case Alphabet List" : "Alphabetliste mit Großbuchstaben",
        "Lower-case Alphabet List" : "Alphabetliste mit Kleinbuchstaben",
        "Upper-case Roman List" : "Liste mit großgeschriebenen römischen Zeichen",
        "Lower-case Roman List" : "Kleingeschriebene römische Liste",
        "Indent" : "Einzug",
        "Outdent" : "Ausrücken",
        "Find & Replace" : "Suchen und Ersetzen",
        "Insert Link" : "Link einfügen",
        "Find" : "Suchen",
        "Replace" : "Ersetzen",
        "Replace all" : "Alle ersetzen",
        "Match case" : "Groß-/Kleinschreibung beachten",
        "Whole word" : "Ganzes Wort",
        "Reg Ex" : "Regulärer Ausdruck",
        "Info" : "Information",
        "Reached end of module." : "Ende des Moduls wurde erreicht.",
        "Match Not Found" : "Keine Übereinstimmung gefunden",
        "{0} matches replaced" : "{0} Übereinstimmungen ersetzt",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Keine",
        "Header 1" : "Überschrift 1",
        "Header 2" : "Überschrift 2",
        "Header 3" : "Überschrift 3",
        "Header 4" : "Überschrift 4",
        "Header 5" : "Überschrift 5",
        "Header 6" : "Überschrift 6",
        "Select" : "Auswählen",
        "Basic View" : "Einfache Ansicht",
        "FullScreen" : "Vollbild",
        "Expand" : "Erweitern",
        "Collapse" : "Reduzieren",
        "List Type" : "Listentyp",
        "URL" : "URL",
        "Alt Text" : "Alt-Text",
        "Open in new page" : "Auf neuer Seite öffnen"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var es = I18n.es = {};

    es.strings = {
        "Undo" : "Deshacer",
        "Redo" : "Rehacer",
        "Bold" : "Negrita",
        "Italic" : "Cursiva",
        "Underline" : "Subrayado",
        "Super-script" : "Superíndice",
        "Sub-script" : "Subíndice",
        "Text Color" : "Color del texto",
        "Highlight Color" : "Color de resaltado",
        "Font Family" : "Familia de fuentes",
        "Font Size" : "Tamaño de fuente",
        "Line Height" : "Altura de la línea",
        "Letter Spacing" : "Espaciado entre letras",
        "Paragraph Format" : "Formato de párrafo",
        "Justify Left" : "Justificar a la izquierda",
        "Justify Center" : "Justificar al centro",
        "Justify Full" : "Justificar todo",
        "Justify Right" : "Justificar a la derecha",
        "Margin Left" : "Margen izquierdo",
        "Margin Right" : "Margen derecho",
        "Margin Top" : "Margen superior",
        "Margin Bottom" : "Margen inferior",
        "Bulleted List" : "Lista con viñetas",
        "Numbered List" : "Lista numerada",
        "Upper-case Alphabet List" : "Lista de letras del alfabeto en mayúscula",
        "Lower-case Alphabet List" : "Lista de letras del alfabeto en minúscula",
        "Upper-case Roman List" : "Lista de caracteres romanos en minúscula",
        "Lower-case Roman List" : "Lista de caracteres romanos en minúscula",
        "Indent" : "Sangría",
        "Outdent" : "Anular sangría",
        "Find & Replace" : "Buscar y reemplazar",
        "Insert Link" : "Insertar vínculo",
        "Find" : "Buscar",
        "Replace" : "Reemplazar",
        "Replace all" : "Reemplazar todo",
        "Match case" : "Coincidir mayúsculas y minúsculas",
        "Whole word" : "Palabra completa",
        "Reg Ex" : "Reg ex",
        "Info" : "Información",
        "Reached end of module." : "Fin del módulo alcanzado.",
        "Match Not Found" : "Coincidencia no encontrada",
        "{0} matches replaced" : "{0} coincidencias reemplazadas",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Ninguno",
        "Header 1" : "Cabecera 1",
        "Header 2" : "Cabecera 2",
        "Header 3" : "Cabecera 3",
        "Header 4" : "Cabecera 4",
        "Header 5" : "Cabecera 5",
        "Header 6" : "Cabecera 6",
        "Select" : "Seleccionar",
        "Basic View" : "Vista básica",
        "FullScreen" : "Pantalla completa",
        "Expand" : "Expandir",
        "Collapse" : "Contraer",
        "List Type" : "Tipo de lista",
        "URL" : "URL",
        "Alt Text" : "Texto alternativo",
        "Open in new page" : "Abrir en nueva página"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var fr = I18n.fr = {};

    fr.strings = {
        "Undo" : "Annuler",
        "Redo" : "Rétablir",
        "Bold" : "Gras",
        "Italic" : "Italique",
        "Underline" : "Souligné",
        "Super-script" : "Exposant",
        "Sub-script" : "Indice",
        "Text Color" : "Couleur du texte",
        "Highlight Color" : "Couleur de surbrillance",
        "Font Family" : "Famille de polices",
        "Font Size" : "Taille de la police",
        "Line Height" : "Hauteur de ligne",
        "Letter Spacing" : "Interlettrage",
        "Paragraph Format" : "Format de paragraphe",
        "Justify Left" : "Justifier à gauche",
        "Justify Center" : "Justifier au centre",
        "Justify Full" : "Justifier entièrement",
        "Justify Right" : "Justifier à droite",
        "Margin Left" : "Marge gauche",
        "Margin Right" : "Marge droite",
        "Margin Top" : "Marge supérieure",
        "Margin Bottom" : "Marge inférieure",
        "Bulleted List" : "Liste à puces",
        "Numbered List" : "Liste numérotée",
        "Upper-case Alphabet List" : "Liste alphabétique en majuscules",
        "Lower-case Alphabet List" : "Liste alphabétique en minuscules",
        "Upper-case Roman List" : "Liste en majuscules romaines",
        "Lower-case Roman List" : "Liste en caractères romains minuscules",
        "Indent" : "Retrait",
        "Outdent" : "Retrait négatif",
        "Find & Replace" : "Rechercher et remplacer",
        "Insert Link" : "Insérer un lien",
        "Find" : "Recherche",
        "Replace" : "Remplacer",
        "Replace all" : "Remplacer tout",
        "Match case" : "Respecter la casse",
        "Whole word" : "Mot entier",
        "Reg Ex" : "Exp. rég.",
        "Info" : "Infos",
        "Reached end of module." : "Atteindre la fin du module.",
        "Match Not Found" : "Aucune correspondance trouvée",
        "{0} matches replaced" : "{0} correspondances remplacées",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Aucune",
        "Header 1" : "En-tête 1",
        "Header 2" : "En-tête 2",
        "Header 3" : "En-tête 3",
        "Header 4" : "En-tête 4",
        "Header 5" : "En-tête 5",
        "Header 6" : "En-tête 6",
        "Select" : "Sélectionner",
        "Basic View" : "Vue de base",
        "FullScreen" : "Plein écran",
        "Expand" : "Développer",
        "Collapse" : "Réduire",
        "List Type" : "Type de liste",
        "URL" : "URL",
        "Alt Text" : "Autre texte",
        "Open in new page" : "Ouvrir dans une nouvelle page"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var it = I18n.it = {};

    it.strings = {
        "Undo" : "Annulla",
        "Redo" : "Ripeti",
        "Bold" : "Grassetto",
        "Italic" : "Corsivo",
        "Underline" : "Sottolinea",
        "Super-script" : "Apice",
        "Sub-script" : "Pedice",
        "Text Color" : "Colore testo",
        "Highlight Color" : "Colore evidenziazione",
        "Font Family" : "Famiglia di font",
        "Font Size" : "Dimensione font",
        "Line Height" : "Altezza riga",
        "Letter Spacing" : "Spaziatura tra lettere",
        "Paragraph Format" : "Formato paragrafo",
        "Justify Left" : "Giustifica a sinistra",
        "Justify Center" : "Giustifica al centro",
        "Justify Full" : "Giustifica",
        "Justify Right" : "Giustifica a destra",
        "Margin Left" : "Margine sinistro",
        "Margin Right" : "Margine destro",
        "Margin Top" : "Margine superiore",
        "Margin Bottom" : "Margine inferiore",
        "Bulleted List" : "Elenco puntato",
        "Numbered List" : "Elenco numerato",
        "Upper-case Alphabet List" : "Elenco alfabeto maiuscolo",
        "Lower-case Alphabet List" : "Elenco alfabeto minuscolo",
        "Upper-case Roman List" : "Elenco Roman maiuscolo",
        "Lower-case Roman List" : "Elenco Roman minuscolo",
        "Indent" : "Rientro",
        "Outdent" : "Rientro negativo",
        "Find & Replace" : "Trova e sostituisci",
        "Insert Link" : "Inserisci collegamento",
        "Find" : "Trova",
        "Replace" : "Sostituisci",
        "Replace all" : "Sostituisci tutto",
        "Match case" : "Maiuscole/minuscole",
        "Whole word" : "Parola intera",
        "Reg Ex" : "Reg eseg",
        "Info" : "Informazioni",
        "Reached end of module." : "Fine del modulo.",
        "Match Not Found" : "Corrispondenza non trovata",
        "{0} matches replaced" : "{0} corrispondenze sostituite",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Nessuno",
        "Header 1" : "Intestazione 1",
        "Header 2" : "Intestazione 2",
        "Header 3" : "Intestazione 3",
        "Header 4" : "Intestazione 4",
        "Header 5" : "Intestazione 5",
        "Header 6" : "Intestazione 6",
        "Select" : "Seleziona",
        "Basic View" : "Vista di base",
        "FullScreen" : "Schermo intero",
        "Expand" : "Espandi",
        "Collapse" : "Comprimi",
        "List Type" : "Tipo di lista",
        "URL" : "URL",
        "Alt Text" : "Testo alternativo",
        "Open in new page" : "Apri in nuova pagina"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var ja = I18n.ja = {};

    ja.strings = {
        "Undo" : "取り消し",
        "Redo" : "やり直し",
        "Bold" : "太字",
        "Italic" : "イタリック",
        "Underline" : "下線",
        "Super-script" : "上付き文字",
        "Sub-script" : "下付き文字",
        "Text Color" : "テキストカラー",
        "Highlight Color" : "ハイライト表示の色",
        "Font Family" : "フォントファミリー",
        "Font Size" : "フォントサイズ",
        "Line Height" : "行の高さ",
        "Letter Spacing" : "文字間隔",
        "Paragraph Format" : "段落書式",
        "Justify Left" : "左揃え",
        "Justify Center" : "中央揃え",
        "Justify Full" : "両端揃え",
        "Justify Right" : "右揃え",
        "Margin Left" : "左マージン",
        "Margin Right" : "右マージン",
        "Margin Top" : "上マージン",
        "Margin Bottom" : "下マージン",
        "Bulleted List" : "バレットリスト",
        "Numbered List" : "番号付きリスト",
        "Upper-case Alphabet List" : "大文字アルファベットリスト",
        "Lower-case Alphabet List" : "小文字アルファベットリスト",
        "Upper-case Roman List" : "大文字ローマンリスト",
        "Lower-case Roman List" : "小文字ローマンリスト",
        "Indent" : "インデント",
        "Outdent" : "アウトデント",
        "Find & Replace" : "検索と置換",
        "Insert Link" : "リンクを挿入",
        "Find" : "検索",
        "Replace" : "置換",
        "Replace all" : "すべて置換",
        "Match case" : "大文字 / 小文字を一致",
        "Whole word" : "単語全体",
        "Reg Ex" : "正規表現",
        "Info" : "情報",
        "Reached end of module." : "モジュールの最後に達しました。",
        "Match Not Found" : "一致が見つかりませんでした",
        "{0} matches replaced" : "{0} 個の一致が置換されました",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "適用なし",
        "Header 1" : "ヘッダー 1",
        "Header 2" : "ヘッダー 2",
        "Header 3" : "ヘッダー 3",
        "Header 4" : "ヘッダー 4",
        "Header 5" : "ヘッダー 5",
        "Header 6" : "ヘッダー 6",
        "Select" : "選択",
        "Basic View" : "基本表示",
        "FullScreen" : "フルスクリーン",
        "Expand" : "展開",
        "Collapse" : "隠す",
        "List Type" : "リストタイプ",
        "URL" : "URL",
        "Alt Text" : "代替テキスト",
        "Open in new page" : "新しいページで開く"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var koKR = I18n.koKR = {};

    koKR.strings = {
        "Undo" : "실행 취소",
        "Redo" : "다시 실행",
        "Bold" : "볼드체",
        "Italic" : "이탤릭체",
        "Underline" : "밑줄",
        "Super-script" : "위 첨자",
        "Sub-script" : "아래 첨자",
        "Text Color" : "텍스트 색상",
        "Highlight Color" : "강조 색상",
        "Font Family" : "글꼴 모음",
        "Font Size" : "글꼴 크기",
        "Line Height" : "선 높이",
        "Letter Spacing" : "문자 간격",
        "Paragraph Format" : "단락 형식",
        "Justify Left" : "왼쪽 맞춤",
        "Justify Center" : "가운데 맞춤",
        "Justify Full" : "전체 맞춤",
        "Justify Right" : "오른쪽 맞춤",
        "Margin Left" : "왼쪽 여백",
        "Margin Right" : "오른쪽 여백",
        "Margin Top" : "상단 여백",
        "Margin Bottom" : "하단 여백",
        "Bulleted List" : "글머리 기호 목록",
        "Numbered List" : "번호 매기기 목록",
        "Upper-case Alphabet List" : "대문자 알파벳 목록",
        "Lower-case Alphabet List" : "소문자 알파벳 목록",
        "Upper-case Roman List" : "대문자 로마자 목록",
        "Lower-case Roman List" : "소문자 로마자 목록",
        "Indent" : "들여쓰기",
        "Outdent" : "내어쓰기",
        "Find & Replace" : "찾기 및 바꾸기",
        "Insert Link" : "링크 삽입",
        "Find" : "찾기",
        "Replace" : "바꾸기",
        "Replace all" : "모두 바꾸기",
        "Match case" : "대소문자 일치",
        "Whole word" : "단어 단위로만",
        "Reg Ex" : "일반 표현식",
        "Info" : "정보",
        "Reached end of module." : "모듈 끝에 도달했습니다.",
        "Match Not Found" : "일치하는 항목을 찾을 수 없습니다.",
        "{0} matches replaced" : "{0}개의 일치 항목이 대체되었습니다.",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "없음",
        "Header 1" : "머리글 1",
        "Header 2" : "머리글 2",
        "Header 3" : "머리글 3",
        "Header 4" : "머리글 4",
        "Header 5" : "머리글 5",
        "Header 6" : "머리글 6",
        "Select" : "선택",
        "Basic View" : "기본 뷰",
        "FullScreen" : "전체화면",
        "Expand" : "확장",
        "Collapse" : "축소",
        "List Type" : "목록 유형",
        "URL" : "URL",
        "Alt Text" : "Alt 속성",
        "Open in new page" : "새 페이지에서 열기"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var ptBR = I18n.ptBR = {};

    ptBR.strings = {
        "Undo" : "Desfazer",
        "Redo" : "Refazer",
        "Bold" : "Negrito",
        "Italic" : "Itálico",
        "Underline" : "Sublinhado",
        "Super-script" : "Sobrescrito",
        "Sub-script" : "Subscrito",
        "Text Color" : "Cor do texto",
        "Highlight Color" : "Cor de realce",
        "Font Family" : "Família de fontes",
        "Font Size" : "Tamanho da fonte",
        "Line Height" : "Altura da linha",
        "Letter Spacing" : "Espaçamento entre Letras",
        "Paragraph Format" : "Formato de parágrafo",
        "Justify Left" : "Justificar à esquerda",
        "Justify Center" : "Justificar no centro",
        "Justify Full" : "Justificar tudo",
        "Justify Right" : "Justificar à direita",
        "Margin Left" : "Margem esquerda",
        "Margin Right" : "Margem direita",
        "Margin Top" : "Margem superior",
        "Margin Bottom" : "Margem inferior",
        "Bulleted List" : "Lista com marcadores",
        "Numbered List" : "Lista numerada",
        "Upper-case Alphabet List" : "Lista alfabética em maiúsculas",
        "Lower-case Alphabet List" : "Lista alfabética em minúsculas",
        "Upper-case Roman List" : "Lista de algarismos romanos maiúsculos",
        "Lower-case Roman List" : "Algarismos Romanos Minúsculos",
        "Indent" : "Recuo",
        "Outdent" : "Recuo para a esquerda",
        "Find & Replace" : "Localizar e substituir",
        "Insert Link" : "Inserir link",
        "Find" : "Localizar",
        "Replace" : "Substituir",
        "Replace all" : "Substituir tudo",
        "Match case" : "Diferenciar maiúsculas de minúsculas",
        "Whole word" : "Palavra inteira",
        "Reg Ex" : "Reg Ex",
        "Info" : "Informações",
        "Reached end of module." : "Atingiu o fim do módulo.",
        "Match Not Found" : "Correspondência não encontrada",
        "{0} matches replaced" : "{0} correspondências substituídas",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Genebra",
        "Georgia" : "Geórgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "Nenhum",
        "Header 1" : "Cabeçalho 1",
        "Header 2" : "Cabeçalho 2",
        "Header 3" : "Cabeçalho 3",
        "Header 4" : "Cabeçalho 4",
        "Header 5" : "Cabeçalho 5",
        "Header 6" : "Cabeçalho 6",
        "Select" : "Selecionar",
        "Basic View" : "Exibição básica",
        "FullScreen" : "Tela inteira",
        "Expand" : "Expandir",
        "Collapse" : "Contrair",
        "List Type" : "Tipo de lista",
        "URL" : "URL",
        "Alt Text" : "Texto alternativo",
        "Open in new page" : "Abrir em nova página"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var zhCN = I18n.zhCN = {};

    zhCN.strings = {
        "Undo" : "撤消",
        "Redo" : "恢复",
        "Bold" : "粗体",
        "Italic" : "斜体",
        "Underline" : "下划线",
        "Super-script" : "上标",
        "Sub-script" : "下标",
        "Text Color" : "文本颜色",
        "Highlight Color" : "突出显示颜色",
        "Font Family" : "字体系列",
        "Font Size" : "字体大小",
        "Line Height" : "行高",
        "Letter Spacing" : "字母间距",
        "Paragraph Format" : "段落格式",
        "Justify Left" : "左对齐",
        "Justify Center" : "居中对齐",
        "Justify Full" : "全部两端对齐",
        "Justify Right" : "右对齐",
        "Margin Left" : "左边距",
        "Margin Right" : "右边距",
        "Margin Top" : "上边距",
        "Margin Bottom" : "下边距",
        "Bulleted List" : "项目符号列表",
        "Numbered List" : "编号列表",
        "Upper-case Alphabet List" : "大写字母列表",
        "Lower-case Alphabet List" : "小写字母列表",
        "Upper-case Roman List" : "大写罗马字母列表",
        "Lower-case Roman List" : "小写罗马字母列表",
        "Indent" : "缩进",
        "Outdent" : "升级",
        "Find & Replace" : "查找和替换",
        "Insert Link" : "插入链接",
        "Find" : "查找",
        "Replace" : "替换",
        "Replace all" : "全部替换",
        "Match case" : "区分大小写",
        "Whole word" : "全字",
        "Reg Ex" : "正则表达式",
        "Info" : "信息",
        "Reached end of module." : "已到模块末尾。",
        "Match Not Found" : "未找到匹配项",
        "{0} matches replaced" : "{0} 个匹配项已替换",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "无",
        "Header 1" : "标题 1",
        "Header 2" : "标题 2",
        "Header 3" : "标题 3",
        "Header 4" : "标题 4",
        "Header 5" : "标题 5",
        "Header 6" : "标题 6",
        "Select" : "选择",
        "Basic View" : "基本视图",
        "FullScreen" : "全屏",
        "Expand" : "展开",
        "Collapse" : "折叠",
        "List Type" : "列表类型",
        "URL" : "URL",
        "Alt Text" : "切换文本",
        "Open in new page" : "在新页面中打开"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 24/10/2016.
 */

(function (I18n) {

    var zhTW = I18n.zhTW = {};

    zhTW.strings = {
        "Undo" : "復原",
        "Redo" : "重做",
        "Bold" : "粗體",
        "Italic" : "斜體",
        "Underline" : "底線",
        "Super-script" : "上標",
        "Sub-script" : "下標",
        "Text Color" : "文字色彩",
        "Highlight Color" : "亮顯顏色",
        "Font Family" : "字型系列",
        "Font Size" : "字型大小",
        "Line Height" : "行高",
        "Letter Spacing" : "字母間隔",
        "Paragraph Format" : "段落格式",
        "Justify Left" : "向左對齊",
        "Justify Center" : "置中對齊",
        "Justify Full" : "左右對齊",
        "Justify Right" : "向右對齊",
        "Margin Left" : "左邊距",
        "Margin Right" : "右邊距",
        "Margin Top" : "上邊距",
        "Margin Bottom" : "下邊距",
        "Bulleted List" : "項目符號清單",
        "Numbered List" : "編號清單",
        "Upper-case Alphabet List" : "大寫字母清單",
        "Lower-case Alphabet List" : "小寫字母清單",
        "Upper-case Roman List" : "大寫 Roman 字清單",
        "Lower-case Roman List" : "小寫 Roman 清單",
        "Indent" : "縮排",
        "Outdent" : "凸排",
        "Find & Replace" : "尋找和取代",
        "Insert Link" : "插入連結",
        "Find" : "尋找",
        "Replace" : "替換",
        "Replace all" : "全部取代",
        "Match case" : "符合大小寫",
        "Whole word" : "全字",
        "Reg Ex" : "規則運算式",
        "Info" : "資訊",
        "Reached end of module." : "到達模組終點。",
        "Match Not Found" : "找不到相符的",
        "{0} matches replaced" : "取代{0}符合的項目",
        "Times New Roman" : "Times New Roman",
        "Arial" : "Arial",
        "Courier" : "Courier",
        "Courier New" : "Courier New",
        "Geneva" : "Geneva",
        "Georgia" : "Georgia",
        "Helvetica" : "Helvetica",
        "Tahoma" : "Tahoma",
        "Times" : "Times",
        "Verdana" : "Verdana",
        "None" : "無",
        "Header 1" : "頁首 1",
        "Header 2" : "頁首 2",
        "Header 3" : "頁首 3",
        "Header 4" : "頁首 4",
        "Header 5" : "頁首 5",
        "Header 6" : "頁首 6",
        "Select" : "選取",
        "Basic View" : "基本檢視",
        "FullScreen" : "全螢幕",
        "Expand" : "展開",
        "Collapse" : "收縮",
        "List Type" : "列表類型",
        "URL" : "網址",
        "Alt Text" : "替代文字",
        "Open in new page" : "在新的頁面中開啟"
    };
})(Form.rte.I18n);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/28/2016.
 */

window.Form = window.Form || {};

Form.rte = Form.rte || {};

Form.rte.util = Form.rte.util || {};

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 8/1/2016.
 */
(function (ns) {

    var RTEUtils = ns.RTEUtils = {};

    RTEUtils.isIE = function () {
        var ua = window.navigator.userAgent;
        var msie = ua.indexOf('MSIE ');
        if (msie > 0) {
            // IE 10 or older => return version number
            return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
        }
        var trident = ua.indexOf('Trident/');
        if (trident > 0) {
            // IE 11 => return version number
            var rv = ua.indexOf('rv:');
            return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
        }
        var edge = ua.indexOf('Edge/');
        if (edge > 0) {
            // IE 12 => return version number
            return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
        }
        // other browser
        return false;
    };
    RTEUtils.addSpectrumGradient = function (selector, colorValue) {
        if (selector) {
            $(selector).css({"background-image" : "-webkit-gradient(linear, left top, right top, color-stop(0, #fff), color-stop(.5, #" + colorValue + "), color-stop(1, #000))"});
            $(selector).css({"background-image" : "-moz-linear-gradient(left center, #fff 0, #" + colorValue + " 50%, #000 100%)"});
            $(selector).css({"background-image" : "-webkit-linear-gradient(left, #fff 0, #" + colorValue + " 50%, #000 100%)"});
            $(selector).css({"background-image" : "-o-linear-gradient(left, #fff 0, #" + colorValue + " 50%, #000 100%)"});
            $(selector).css({"background-image" : "linear-gradient(to right, #fff 0, #" + colorValue + " 50%, #000 100%)"});
            $(selector).css({"background-repeat" : "repeat-x"});
        }
    };

})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var StringHelper = ns.StringHelper = {};

    /**
     * Removes any leading and trailing slashes, either '/' or '\', on the specified string.
     * @param value The string from which slashes are to be trimmed.
     * @return The original string less any trailing slashes.
     */
    StringHelper.trimSlashes = function (value) {

        if (!value) {// if null or empty
            return value;
        }

        var len = value.length;

        // remove leading slashes
        var start = 0; // must be index of first character to include
        var c = value.charAt(start);
        while (c == '/' || c == '\\') {
            start++;
            if (start >= len) {
                start = len;
                break;
            }
            c = value.charAt(start);
        }
        if (start >= len) {// all slashes
            return "";
        }

        // at this point, there's at least one character we want to retain

        // remove trailing slashes
        var end = len; // must be 1 more than the last character we want to include
        c = value.charAt(end - 1);
        while (c == '/' || c == '\\') {
            end--;
            if (end < 0) {
                end = 0;
                break;
            }

            c = value.charAt(end - 1);
        }
        return value.substring(start, end);
    };
    StringHelper.repeat = function (c, count) {
        var s = "";
        if (c == null) {
            return s;
        }

        for (var i = 0; i < count; i++) {
            s += c;
        }
        return s;
    };
    /**
     * Determines if the specified string has the specified postfix.
     * @param str The string to be verified.
     * @param postFix The postfix to search for.
     * @return True if str has the postfix specified; true if postfix is null/empty since any non-null string can have an empty postfix;
     *  false if str is null or does not have the specified postfix.
     */
    StringHelper.hasPostFix = function (str, postFix) {
        if (str == null) {
            return false;
        }

        if (!postFix) {
            return true;
        } // any string has an empty postfix!
        return (str.indexOf(postFix) == (str.length - postFix.length));
    };

    /**
     * Tests the string to see if it only contains whitespace characters. This is slightly different from
     *  <code>StringUtil.isWhitespace()</code> in that it tests all characters, not just one.
     * @param str The string to test.
     * @return True if the str is made-up entirely of whitespace; false if not. Null strings will result in true.
     */
    StringHelper.isWhitespace = function (str) {
        if (str == null) {
            return true;
        }
        return str.match(/[^\s]+/g) == null; // matches at least one non-whitespace character so if there's no match, it's entirely whitespace
    };

    /**
     * Stretches the specified string to the specified length using the specified pad character.
     * @param str The string to stretch.
     * @param pad The (single) character to use when stretching.
     * @param length The length to stretch to.
     * @param prefix True if the pad should be added to the left (before the contents of the string); false if it should be appended
     *  to the end of the contents of the string.
     * @return The stretched string. If <code>str</code> is null or empty, it simply becomes a string of <code>pad</code> characters
     *  of the specified <code>length</code>.
     * @throws Error Pad must be a single character.
     */
    StringHelper.stretch = function (str, pad, length, prefix) {
        if (!pad || length <= 0) {
            return str;
        }

        if (pad.length != 1) {
            throw new Error("pad must be a single character: " + pad);
        } // assert
        var i = 0;
        if (str == null) {
            str = "";
            for (; i < length; i++) {
                str += pad;
            }
            return str;
        }
        if (str.length >= length) {
            return str;
        }
        var count = length - str.length;
        for (; i < count; i++) {
            if (prefix) {
                str = pad + str;
            } else {
                str = str + pad;
            }
        }
        return str;
    };

    /**
     * Replaces the all the occurance of target string with replacement string for a given input string
     * @param inputString The Input String
     * @param target
     * @param replacement
     * @return
     *
     */
    StringHelper.replaceAll = function (inputString, target, replacement) {
        if (inputString == null || target == null) {
            return inputString;
        }
        var escapedTarget = StringHelper.escapeRegexChars(target);
        var pattern = new RegExp(escapedTarget, "g");
        var newString = inputString.replace(pattern, replacement);
        return newString;
    };

    StringHelper.escapeRegexChars = function (s) {
        var newString = s.replace(new RegExp("([{}\(\)\^$&.\*\?\/\+\|\[\\\\]|\]|\-)", "g"), "\\$1");
        return newString;
    };

    StringHelper.restrict = function (str, restrict) {
        // A null 'restrict' string means all characters are allowed.
        if (restrict == null) {
            return str;
        }

        // An empty 'restrict' string means no characters are allowed.
        if (restrict == "") {
            return "";
        }
        // Otherwise, we need to test each character in 'str'
        // to determine whether the 'restrict' string allows it.
        var charCodes = [];

        var n = str.length;
        for (var i = 0; i < n; i++) {
            var charCode = str.charCodeAt(i);
            if (StringHelper.testCharacter(charCode, restrict)) {
                charCodes.push(charCode);
            }
        }
        return String.fromCharCode.apply(null, charCodes);
    };

    StringHelper.testCharacter = function (charCode, restrict) {
        var allowIt = false;
        var inBackSlash = false;
        var inRange = false;
        var setFlag = true;
        var lastCode = 0;
        var n = restrict.length;
        var code;

        if (n > 0) {
            code = restrict.charCodeAt(0);
            if (code == 94) {// caret
                allowIt = true;
            }
        }
        for (var i = 0; i < n; i++) {
            code = restrict.charCodeAt(i);
            var acceptCode = false;
            if (!inBackSlash) {
                if (code == 45) {// hyphen
                    inRange = true;
                } else if (code == 94) {// caret
                    setFlag = !setFlag;
                } else if (code == 92) {// backslash
                    inBackSlash = true;
                } else {
                    acceptCode = true;
                }
            } else {
                acceptCode = true;
                inBackSlash = false;
            }
            if (acceptCode) {
                if (inRange) {
                    if (lastCode <= charCode && charCode <= code) {
                        allowIt = setFlag;
                    }
                    inRange = false;
                    lastCode = 0;
                } else {
                    if (charCode == code) {
                        allowIt = setFlag;
                    }
                    lastCode = code;
                }
            }
        }
        return allowIt;
    };

    StringHelper.endsWith = function (str, suffix) {
        if (str && suffix && str.indexOf(suffix, str.length - suffix.length) !== -1) {
            return true;
        } else {
            return false;
        }
    };

    StringHelper.startsWith = function (str, prefix) {
        if (str && prefix && str.indexOf(prefix) === 0) {
            return true;
        } else {
            return false;
        }
    };

})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

var XfaElem, XfaXhtml, XfaSchema, XfaAtt, XfaVal;

var XfaData;

var XfaMimeType;

var XfaDataElem;

XfaDataElem = Form.rte.util.XfaDataElem = {};
XfaDataElem.DATASETS = "datasets";
XfaDataElem.DATA = "data";
XfaDataElem._elemTagMap = null;
XfaDataElem.isElement = function (elemTag) {
    // create on first use
    if (!XfaDataElem._elemTagMap) {

        XfaDataElem._elemTagMap = {};
        var element, staticConstList = Object.keys(XfaDataElem);

        for (var index = 0; index < staticConstList.length; index++) {
            element = staticConstList[index];
            // element members are expected not to have any underscores in their names
            if (element.indexOf("_") < 0 && typeof XfaDataElem[element] == "string") {
                XfaDataElem._elemTagMap[XfaDataElem[element]] = true;
            }
        }
    }
    return (elemTag in XfaDataElem._elemTagMap);
};

XfaData = Form.rte.util.XfaData = {};
XfaData.XFADATANSURI = "http://www.xfa.org/schema/xfa-data/1.0/";

XfaMimeType = Form.rte.util.XfaMimeType = {};
XfaMimeType.JPEG = "image/jpg";
/** MIME type for TIFF images. */
XfaMimeType.TIFF = "image/tif";
/** MIME type for GIF images. */
XfaMimeType.GIF = "image/gif";
/** MIME type for bitmap images. */
XfaMimeType.BMP = "image/bmp";
/** MIME type for PNG images (only indexed PNGs with one transparent color are supported in XFA forms). */
XfaMimeType.PNG = "image/png";
/** MIME type for plain text. */
XfaMimeType.PLAINTEXT = "text/plain";
/** MIME type for rich text. */
XfaMimeType.RICHTEXT = "text/html";
/** MIME type for xml text. */
XfaMimeType.XMLTEXT = "text/xml";

XfaXhtml = Form.rte.util.XfaXhtml = {};
XfaXhtml.XHTMLNSURI = "http://www.w3.org/1999/xhtml";
/** AXTE API Version used in XFA XHTML &lt;body&gt; tag (currently set to that which is used with LiveCycle ES Update 1 (Designer 8.2)). */
XfaXhtml.AXTEAPIVERSION = "2.7.0.0";

/** The root node of XFA rich text (XHTML) as set in rich text draws and fields. The entire rich text value is contained within a &lt;body&gt; element. */
XfaXhtml.BODY = "body";

/** Spacerun style name. */
XfaXhtml.SPACERUNSTYLENAME = "xfa-spacerun";
/** Spacerun style value. */
XfaXhtml.SPACERUNSTYLEVALUE = "yes";
/** Spacerun style (name:value). */
XfaXhtml.SPACERUNSTYLE = XfaXhtml.SPACERUNSTYLENAME + ':' + XfaXhtml.SPACERUNSTYLEVALUE;
/** Spacerun opening tag. */
XfaXhtml.SPACERUNOPEN = '<span style="' + XfaXhtml.SPACERUNSTYLE + '">';
/** Spacerun closing tag. */
XfaXhtml.SPACERUNCLOSE = '</span>';
XfaElem = Form.rte.util.XfaElem = {};
XfaElem.APPEARANCEFILTER = "appearanceFilter";
XfaElem.ARC = "arc";
XfaElem.AREA = "area";
XfaElem.BARCODE = "barcode";
XfaElem.BIND = "bind";
XfaElem.BOOLEAN = "boolean";
XfaElem.BORDER = "border";
XfaElem.BUTTON = "button";
XfaElem.CAPTION = "caption";
XfaElem.CERTIFICATE = "certificate";
XfaElem.CHECKBUTTON = "checkButton";
XfaElem.CHOICELIST = "choiceList";
XfaElem.COLOR = "color";
XfaElem.CONTENTAREA = "contentArea";
XfaElem.DATE = "date";
XfaElem.DATETIME = "dateTime";
XfaElem.DATETIMEEDIT = "dateTimeEdit";
XfaElem.DECIMAL = "decimal";
XfaElem.DEFAULTUI = "defaultUi";
XfaElem.DIGESTMETHOD = "digestMethod";
XfaElem.DRAW = "draw";
XfaElem.EDGE = "edge";
XfaElem.ENCODING = "encoding";
XfaElem.EXCLGROUP = "exclGroup";
XfaElem.EXDATA = "exData";
XfaElem.EXOBJECT = "exObject";
XfaElem.EVENT = "event";
XfaElem.EXECUTE = "execute";
XfaElem.FIELD = "field";
XfaElem.FILL = "fill";
XfaElem.FLOAT = "float";
XfaElem.FONT = "font";
XfaElem.HANDLER = "handler";
XfaElem.IMAGE = "image";
XfaElem.IMAGEEDIT = "imageEdit";
XfaElem.INTEGER = "integer";
XfaElem.ITEMS = "items";
XfaElem.KEEP = "keep";
XfaElem.LINE = "line";
XfaElem.LINEAR = "linear";
XfaElem.LOCKDOCUMENT = "lockDocument";
XfaElem.MARGIN = "margin";
XfaElem.MEDIUM = "medium";
XfaElem.NUMERICEDIT = "numericEdit";
XfaElem.OID = "oid";
XfaElem.PAGEAREA = "pageArea";
XfaElem.PAGESET = "pageSet";
XfaElem.PARA = "para";
XfaElem.PASSWORDEDIT = "passwordEdit";
XfaElem.PATTERN = "pattern";
XfaElem.PICTURE = "picture";
XfaElem.RADIAL = "radial";
XfaElem.RECTANGLE = "rectangle";
XfaElem.REASON = "reason";
XfaElem.REF = "ref";
XfaElem.SCRIPT = "script";
XfaElem.SIGNATURE = "signature";
XfaElem.SIGNDATA = "signData";
XfaElem.SOLID = "solid";
XfaElem.SPEAK = "speak";
XfaElem.STIPPLE = "stipple";
XfaElem.SUBFORM = "subform";
XfaElem.SUBFORMSET = "subformSet";
XfaElem.SUBJECTDN = "subjectDN";
XfaElem.SUBMIT = "submit";
XfaElem.TEMPLATE = "template";
XfaElem.TEXT = "text";
XfaElem.TEXTEDIT = "textEdit";
XfaElem.TIME = "time";
XfaElem.TOOLTIP = "toolTip";
XfaElem.UI = "ui";
XfaElem.VALUE = "value";
XfaElem.VARIABLES = "variables";
XfaElem._elemTagMap = null;

/**
 * Determines if the specified element name is a valid XFA Template element name.
 * @param elemTag The name to test.
 * @return True if it's an XFA Template element name; false if not.
 */
XfaElem.isElement = function (elemTag) {
    // create on first use
    if (!XfaElem._elemTagMap) {
        XfaElem._elemTagMap = {};
        var element, staticConstList = Object.keys(XfaElem);
        for (var index = 0; index < staticConstList.length; index++) {
            element = staticConstList[index];
            // element members are expected not to have any underscores in their names
            if (element.indexOf("_") < 0 && typeof XfaElem[element] == "string") {
                XfaElem._elemTagMap[XfaElem[element]] = true;
            }
        }
    }
    return (elemTag in XfaElem._elemTagMap);
};

XfaAtt = Form.rte.util.XfaAtt = {};

XfaAtt.ACTIVITY = "activity";
XfaAtt.ASPECT = "aspect";
XfaAtt.ALLOWRICHTEXT = "allowRichText";
XfaAtt.BOTTOMINSET = "bottomInset";
XfaAtt.COMMITON = "commitOn";
XfaAtt.CONTENTTYPE = "contentType";
XfaAtt.H = "h";
XfaAtt.HREF = "href";
XfaAtt.ID = "id";
XfaAtt.INTACT = "intact";
XfaAtt.LAYOUT = "layout";
XfaAtt.LEFTINSET = "leftInset";
XfaAtt.LONG = "long";
XfaAtt.MARGINLEFT = "marginLeft";
XfaAtt.MARGINRIGHT = "marginRight";
XfaAtt.MATCH = "match";
XfaAtt.MAXCHARS = "maxChars";
XfaAtt.MAXH = "maxH";
XfaAtt.MAXLENGTH = "maxLength";
XfaAtt.MAXW = "maxW";
XfaAtt.MINH = "minH";
XfaAtt.MINW = "minW";
XfaAtt.MULTILINE = "multiLine";
XfaAtt.NAME = "name";
XfaAtt.OPEN = "open";
XfaAtt.ORIENTATION = "orientation";
XfaAtt.PAGEPOSITION = "pagePosition";
XfaAtt.PLACEMENT = "placement";
XfaAtt.PRESENCE = "presence";
XfaAtt.REF = "ref";
XfaAtt.RELATION = "relation";
XfaAtt.RESERVE = "reserve";
XfaAtt.RIGHTINSET = "rightInset";
XfaAtt.RUNAT = "runAt";
XfaAtt.SAVE = "save";
XfaAtt.SHORT = "short";
XfaAtt.SIZE = "size";
XfaAtt.SPACEABOVE = "spaceAbove";
XfaAtt.SPACEBELOW = "spaceBelow";
XfaAtt.STOCK = "stock";
XfaAtt.STROKE = "stroke";
XfaAtt.TEXTENTRY = "textEntry";
XfaAtt.TOPINSET = "topInset";
XfaAtt.TYPEFACE = "typeface";
XfaAtt.USE = "use";
XfaAtt.USEHREF = "usehref";
XfaAtt.VALIGN = "vAlign";
XfaAtt.VALUE = "value";
XfaAtt.WEIGHT = "weight";
XfaAtt.W = "w";
XfaAtt.X = "x";
XfaAtt.Y = "y";
/** Map of attribute names (string values of static attribute constant members of XfaAtt) to an as-yet unused value. */
XfaAtt._attTagMap = null;
XfaAtt.isAttribute = function (attTag) {
    // create on first use
    if (!XfaAtt._attTagMap) {
        XfaAtt._attTagMap = {};
        var element, staticConstList = Object.keys(XfaAtt);
        for (var index = 0; index < staticConstList.length; index++) {
            element = staticConstList[index];
            // element members are expected not to have any underscores in their names
            if (element.indexOf("_") < 0 && typeof XfaAtt[element] == "string") {
                this._attTagMap[XfaAtt[element]] = true;
            }
        }
    }
    return (attTag in this._attTagMap);
};

XfaVal = Form.rte.util.XfaVal = {};

XfaVal.ACTUAL = "actual";
XfaVal.ALWAYS = "always";
XfaVal.ANY = "any";
XfaVal.APPXFORMCALC = "application/x-formcalc";
XfaVal.APPXJAVASCRIPT = "application/x-javascript";
XfaVal.BOLD = "bold";
XfaVal.BOTH = "both";
XfaVal.BOTTOM = "bottom";
XfaVal.CHANGE = "change";
XfaVal.CLICK = "click";
XfaVal.CLIENT = "client";
XfaVal.CONTENTAREA = "contentArea";
XfaVal.DASHDOT = "dashDot";
XfaVal.DASHDOTDOT = "dashDotDot";
XfaVal.DASHED = "dashed";
XfaVal.DATAREF = "dataRef";
XfaVal.DOCCLOSE = "docClose";
XfaVal.DOCREADY = "docReady";
XfaVal.DOTTED = "dotted";
XfaVal.EMBOSSED = "embossed";
XfaVal.ENTER = "enter";
XfaVal.ETCHED = "etched";
XfaVal.EXIT = "exit";
XfaVal.FIRST = "first";
XfaVal.FIT = "fit";
XfaVal.FULL = "full";
XfaVal.GLOBAL = "global";
XfaVal.HEIGHT = "height";
XfaVal.HIDDEN = "hidden";
XfaVal.INDEXCHANGE = "indexChange";
XfaVal.INITIALIZE = "initialize";
XfaVal.INLINE = "inline";
XfaVal.INVISIBLE = "invisible";
XfaVal.LANDSCAPE = "landscape";
XfaVal.LAST = "last";
XfaVal.LEFT = "left";
XfaVal.LETTER = "letter";
XfaVal.LOWERED = "lowered";
XfaVal.LRTB = "lr-tb";
XfaVal.MIDDLE = "middle";
XfaVal.MOUSEDOWN = "mouseDown";
XfaVal.MOUSEENTER = "mouseEnter";
XfaVal.MOUSEEXIT = "mouseExit";
XfaVal.MOUSEUP = "mouseUp";
XfaVal.MULTISELECT = "multiSelect";
XfaVal.NONE = "none";
XfaVal.NORMAL = "normal";
XfaVal.ONCE = "once";
XfaVal.ONENTRY = "onEntry";
XfaVal.ONLY = "only";
XfaVal.ORDEREDOCCURRENCE = "orderedOccurrence";
XfaVal.PAGEAREA = "pageArea";
XfaVal.PORTRAIT = "portrait";
XfaVal.POSITION = "position";
XfaVal.POSTEXECUTE = "postExecute";
XfaVal.POSTOPEN = "postOpen";
XfaVal.POSTPRINT = "postPrint";
XfaVal.POSTSAVE = "postSave";
XfaVal.POSTSIGN = "postSign";
XfaVal.POSTSUBMIT = "postSubmit";
XfaVal.PREEXECUTE = "preExecute";
XfaVal.PREOPEN = "preOpen";
XfaVal.PREPRINT = "prePrint";
XfaVal.PRESAVE = "preSave";
XfaVal.PRESIGN = "preSign";
XfaVal.PRESUBMIT = "preSubmit";
XfaVal.RAISED = "raised";
XfaVal.READY = "ready";
XfaVal.REST = "rest";
XfaVal.RIGHT = "right";
XfaVal.RLTB = "rl-tb";
XfaVal.ROW = "row";
XfaVal.SELECT = "select";
XfaVal.SERVER = "server";
XfaVal.SOLID = "solid";
XfaVal.TABLE = "table";
XfaVal.TB = "tb";
XfaVal.TOP = "top";
XfaVal.USERCONTROL = "userControl";
XfaVal.VISIBLE = "visible";
XfaVal.WIDTH = "width";

XfaSchema = Form.rte.util.XfaSchema = {};
/** XFA namespace prefix. */
XfaSchema.XFANS = "xfa";

/** XFA 2.8 namespace URI. */
XfaSchema.XFAVERSION28 = "http://www.xfa.org/schema/xfa-template/2.8/";
/** XFA version for all new templates. */
XfaSchema.TEMPLATEVERSION = XfaSchema.XFAVERSION28;

/** Default for schema values that are the number zero. */
XfaSchema.ZERO = "0";
/** Default for schema values that are the number one. */
XfaSchema.ONE = "1";
/** Default for schema values that are the number minus one. */
XfaSchema.MINUSONE = "-1";
/** Point units. */
XfaSchema.UNITPOINT = "pt";
/** Millimeter units. */
XfaSchema.UNITMILLI = "mm";
/** Centimeter units. */
XfaSchema.UNITCENTI = "cm";
/** Inch units. */
XfaSchema.UNITINCH = "in";
/** Default units for schema values that are measurements. */
XfaSchema.DEFAULTUNITS = XfaSchema.UNITINCH;
/** Default output units whem editing measurement values. Millimeters are more precise. */
XfaSchema.WRITEUNITS = XfaSchema.UNITMILLI;
/** Default for schema values that are "cdata". */
XfaSchema.CDATA = "";
/** Default for schema values that are "xml-id". */
XfaSchema.XMLID = "";
/** Default font for typeface properties. Actual default is "Courier Std" however "Myriad Pro" is the Adobe standard font. */
XfaSchema.DEFAULTFONT = "Myriad Pro";
/** Black color. */
XfaSchema.BLACK = "0,0,0";

// TODO: Consider moving XfaSchema.XFAFORMDOM into new XfaScripting or scrip.XfaFormDom or something along those lines.
/* XFA Form DOM scripting prefix. */
//XfaSchema.XFAFORMDOM = "xfa.form";

// TODO: Workaround for https://bugs.adobe.com/jira/browse/ASC-2231 (not technically part of the XFA Schema but
//  somehow using the const from XfaSchema rather than XfaFragUtils works better when setting it as the
//  default value for a function parameter).
/** Default name for a new fragment. */
XfaSchema.DEFAULTFRAGNAME = "Fragment1";
/** Default name for a new form object (field, draw, subform, etc.). */
XfaSchema.DEFAULTOBJNAME = "FormObject";
/** Default name for a root subform. */
XfaSchema.DEFAULTROOTNAME = "form1";

/** Default processing instruction domain for PIs generated and read by LC Designer. */
XfaSchema.PIDESDOMAIN = "templateDesigner";

/** Processing instruction that identifies a form object as a fragment. This PI object also defines a "value" property that holds the PI's expected (and only) value. */
XfaSchema.PIFRAGISFRAG = {domain : XfaSchema.PIDESDOMAIN, key : "isFragment", value : "yes"};
/** Processing instruction that contains the title metadata for a fragment. */
XfaSchema.PIFRAGTITLE = {domain : XfaSchema.PIDESDOMAIN, key : "fragmentTitle"};
/** Processing instruction that contains the description metadata for a fragment. */
XfaSchema.PIFRAGDESC = {domain : XfaSchema.PIDESDOMAIN, key : "fragmentDescription"};

/**
 * Returns true if the specified XFA element tag is a container node (may contain other containers or fields/draws). Protos are excluded.
 * @param elemTag The XFA element tag to check as being a container.
 * @param includeExGrp If true, the &lt;exclGroup&gt; node is considered a container. Otherwise, it is not. Note that in terms of
 *  "content", exclusion group nodes may only contain &lt;field&gt; nodes which is more restrictive than other container types.
 */
XfaSchema.isContainerElem = function (elemTag, includeExGrp) {
    includeExGrp = includeExGrp !== undefined ? includeExGrp : true;

    switch (elemTag) {
        case XfaElem.SUBFORM:
        case XfaElem.SUBFORMSET:
        case XfaElem.AREA:
        case XfaElem.PAGEAREA:
            return true;
            break;

        case XfaElem.EXCLGROUP:
            return includeExGrp;
            break;

        default:
            break;
    }

    return false;
};

/** Returns true if the specified XFA element tag defines form content (could be a field, draw or some type of container node). Protos are excluded. */
XfaSchema.isContentElem = function (elemTag) {
    switch (elemTag) {
        case XfaElem.DRAW:
        case XfaElem.FIELD:
            return true;
            break;
        default:
            break;
    }
    return XfaSchema.isContainerElem(elemTag);
};

/**
 * Returns the default value for a given attribute tag. If the attribute is invalid or unknown, null is returned. If there isn't enough context to determine
 *  the default, null is returned (e.g. the node may be orphaned and a particular parent type is required, like the default for the "allowRichText" can't be
 *  determined if the <code>textEdit</code> node is orphaned because a <code>field</code> or <code>draw</code> parent containing a <code>value</code> is required).
 * @param attTag The attribute name for which to retrieve the default.
 * @param contextNode XFA node that provides necessary context for the default value. For example, the "allowRichText" attribute has different default values
 *  depending on whether the text field/draw has &lt;exData&gt; as its value type or not. This is expected to be the node on which the attribute would be set (i.e.
 *  when attTag is "allowRichText", contextNode is expected to be a &lt;textEdit&gt; node).
 * @return The default value for the attribute or null if the attribute is unknown. Will also return null if contextNode is specified but could not be used
 *  to determine the appropriate default value for the specified attribute.
 * @throws com.adobe.xfa.xfautil.Error Attribute default cannot be correctly determined without both the attribute tag and the context node.
 */
XfaSchema.attDefault = function (attTag, contextNode) {
    if (!attTag || !contextNode) {
        throw new Error("Attribute default cannot be correctly determined without both the attribute tag and the context node.");
        return null;
    }

    // TODO: SCHEMA VALIDATION: Eventually, we'll need to validate that the attribute sought is valid on the given context node.
    var def = null;
    switch (attTag) {
        // NOTE: An auto-generated (from XTG's main code base) XFA spec should be available here for reference:
        // http://xtgwin1.can.adobe.com/main_build/xtg/docs/schema/template-syntax.html

        //////////////////////////////////
        // in alphabetical order
        //////////////////////////////////
        case XfaAtt.ACTIVITY:
            def = XfaVal.CLICK;
            break;
        case XfaAtt.ASPECT:
            def = XfaVal.FIT;
            break;
        case XfaAtt.ALLOWRICHTEXT:
            def = XfaSchema._getAllowRichTextDefault(contextNode);
            break;
        case XfaAtt.BOTTOMINSET:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.COMMITON:
            def = XfaVal.SELECT;
            break;
        case XfaAtt.CONTENTTYPE:
            def = XfaSchema._getContentTypeDefault(contextNode);
            break;
        case XfaAtt.H:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.HREF:
            def = XfaSchema.CDATA;
            break;
        case XfaAtt.ID:
            def = XfaSchema.XMLID;
            break;
        case XfaAtt.INTACT:
            def = XfaSchema._getIntactDefault(contextNode);
            break;
        case XfaAtt.LAYOUT:
            def = XfaVal.POSITION;
            break;
        case XfaAtt.LEFTINSET:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.LONG:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MARGINLEFT:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MARGINRIGHT:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MATCH:
            def = XfaVal.ONCE;
            break;
        case XfaAtt.MAXCHARS:
            def = XfaSchema.ZERO;
            break;
        case XfaAtt.MAXH:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MAXLENGTH:
            def = XfaSchema.MINUSONE;
            break;
        case XfaAtt.MAXW:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MINH:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MINW:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.MULTILINE:
            def = XfaSchema._getMultiLineDefault(contextNode);
            break;
        case XfaAtt.NAME:
            def = XfaSchema.XMLID;
            break;
        case XfaAtt.OPEN:
            def = XfaVal.USERCONTROL;
            break;
        case XfaAtt.ORIENTATION:
            def = XfaVal.PORTRAIT;
            break;
        case XfaAtt.PAGEPOSITION:
            def = XfaVal.ANY;
            break;
        case XfaAtt.PLACEMENT:
            def = XfaVal.LEFT;
            break;
        case XfaAtt.PRESENCE:
            def = XfaVal.VISIBLE;
            break;
        case XfaAtt.REF:
            def = XfaSchema.CDATA;
            break;
        case XfaAtt.RELATION:
            def = XfaVal.ORDEREDOCCURRENCE;
            break;
        case XfaAtt.RESERVE:
            def = XfaSchema.MINUSONE;
            break;
        case XfaAtt.RIGHTINSET:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.RUNAT:
            def = XfaVal.CLIENT;
            break;
        case XfaAtt.SAVE:
            def = XfaSchema.ZERO;
            break;
        case XfaAtt.SHORT:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.SIZE:
            def = "10" + XfaSchema.UNITPOINT;
            break;
        case XfaAtt.SPACEABOVE:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.SPACEBELOW:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.STOCK:
            def = XfaVal.LETTER;
            break;
        case XfaAtt.STROKE:
            def = XfaVal.SOLID;
            break;
        case XfaAtt.TEXTENTRY:
            def = XfaSchema.ZERO;
            break;
        case XfaAtt.TOPINSET:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.TYPEFACE:
            def = XfaSchema.DEFAULTFONT;
            break;
        case XfaAtt.USE:
            def = XfaSchema.CDATA;
            break;
        case XfaAtt.USEHREF:
            def = XfaSchema.CDATA;
            break;
        case XfaAtt.VALIGN:
            def = XfaVal.TOP;
            break;
        case XfaAtt.VALUE:
            def = XfaSchema.BLACK;
            break;
        case XfaAtt.WEIGHT:
            def = XfaVal.NORMAL;
            break;
        case XfaAtt.W:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.X:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;
        case XfaAtt.Y:
            def = XfaSchema.ZERO + XfaSchema.DEFAULTUNITS;
            break;

        default:
            Window.console.error("no default attribute value for '" + attTag + "' tag");
            break;
    }
    return def;
};

/**
 * Returns the default child element class name given a tag that contains a one-of element property.
 * <p>For example, the <code>//field/ui</code> element contains a one-of property which specifies the field's UI type for which the default is <code>textField</code>.
 *  Therefore, calling <code>oneOfDefault(&lt;field&gt;&lt;ui/&gt;&lt;/field&gt;)</code> would return XfaElem.TEXTFIELD.</p>
 * @param contextNode The node whose one-of property default is sought.
 * @return An XFA element name, from XfaElem, which identifies the class name of the default one-of property of the context node. Returns null if no default is defined.
 *  To determine if the an element has a one-of property, you should use XfaSchema.hasOneOfProp().
 * @see com.adobe.xfa.XfaElem
 * @see #hasOneOfProp()
 * @throws com.adobe.xfa.xfautil.Error One-of default cannot be correctly determined without the context node.
 */
XfaSchema.oneOfDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("One-of default cannot be correctly determined without the context node.");
        return null;
    }
    var def = null;
    switch (contextNode.className) {
        // NOTE: An auto-generated (from XTG's main code base) XFA spec should be available here for reference:
        // http://xtgwin1.can.adobe.com/main_build/xtg/docs/schema/template-syntax.html

        //////////////////////////////////
        // in alphabetical order
        //////////////////////////////////
        case XfaElem.EVENT:
            def = XfaElem.SCRIPT;
            break; // no actual default -- our default, as the "XFA application" is <script> (matches XTG default)
        case XfaElem.FILL:
            def = XfaElem.SOLID;
            break; // no actual default -- our default, as the "XFA application" is <solid> (matches XTG default)
        case XfaElem.UI:
            def = XfaElem.TEXTEDIT;
            break; // no actual default -- our default, as the "XFA application" is <textEdit> (matches XTG default)
        case XfaElem.VALUE:
            def = XfaElem.TEXT;
            break; // no actual default -- our default, as the "XFA application" is <text> (matches XTG default)

        default:
            window.console.error("no default one-of element property for '" + contextNode.className + "' tag");
            break;
    }
    return def;
};

/**
 * Determines if the specified XFA element has a one-of property.
 * @param elemTag The XFA element to check for a one-of property.
 * @return True if the XFA element has a one-of property; false if not.
 */
XfaSchema.hasOneOfProp = function (elemTag) {
    var hasOneOf = false;

    switch (elemTag) {
        // NOTE: An auto-generated (from XTG's main code base) XFA spec should be available here for reference:
        // http://xtgwin1.can.adobe.com/main_build/xtg/docs/schema/template-syntax.html

        //////////////////////////////////
        // in alphabetical order
        //////////////////////////////////
        case XfaElem.EVENT:
        case XfaElem.FILL:
        case XfaElem.UI:
        case XfaElem.VALUE:
            hasOneOf = true;
            break;
    }
    return hasOneOf;
};

/**
 * Determines if the specified XFA element class name is a one-of property of the specified context node.
 * <p>For example, calling <code>isOneOfProp(XfaElem.TEXTEDIT, &lt;field&gt;&lt;ui/&gt;&lt;/field&gt;)</code> would return true.</p>
 * @param elemTag The XFA element class name, from XfaElem, which is the tag to test as a one-of property of the context node.
 * @param contextNode The XFA node that provides context to the test since some elements may be one-of properties of some other elements while
 *  they may not be of others. For example, the &lt;text&gt; element is a one-of property of &lt;value&gt; but a 1/n property of &lt;variables&gt;.
 * @throws com.adobe.xfa.xfautil.Error One-of property cannot be correctly identified without the element tag and the context node.
 */
XfaSchema.isOneOfProp = function (elemTag, contextNode) {
    if (!elemTag || !contextNode) {
        throw new Error("One-of property cannot be correctly identified without the element tag and the context node.");
        return false;
    }

    var isOneOf = false;

    switch (contextNode.className) {
        // NOTE: An auto-generated (from XTG's main code base) XFA spec should be available here for reference:
        // http://xtgwin1.can.adobe.com/main_build/xtg/docs/schema/template-syntax.html

        //////////////////////////////////
        // in alphabetical order
        //////////////////////////////////
        case XfaElem.EVENT: {
            switch (elemTag) {
                case XfaElem.EXECUTE:
                case XfaElem.SCRIPT:
                case XfaElem.SIGNDATA:
                case XfaElem.SUBMIT:
                    isOneOf = true;
                    break;
            }
            break;
        }

        case XfaElem.FILL: {
            switch (elemTag) {
                case XfaElem.LINEAR:
                case XfaElem.PATTERN:
                case XfaElem.RADIAL:
                case XfaElem.SOLID:
                case XfaElem.STIPPLE:
                    isOneOf = true;
                    break;
            }
            break;
        }

        case XfaElem.UI: {
            switch (elemTag) {
                case XfaElem.BARCODE:
                case XfaElem.BUTTON:
                case XfaElem.CHECKBUTTON:
                case XfaElem.CHOICELIST:
                case XfaElem.DATETIMEEDIT:
                case XfaElem.DEFAULTUI:
                case XfaElem.EXOBJECT:
                case XfaElem.IMAGEEDIT:
                case XfaElem.NUMERICEDIT:
                case XfaElem.PASSWORDEDIT:
                case XfaElem.SIGNATURE:
                case XfaElem.TEXTEDIT:
                    isOneOf = true;
                    break;
            }
            break;
        }

        case XfaElem.VALUE: {
            switch (elemTag) {
                case XfaElem.ARC:
                case XfaElem.BOOLEAN:
                case XfaElem.DATE:
                case XfaElem.DATETIME:
                case XfaElem.DECIMAL:
                case XfaElem.EXDATA:
                case XfaElem.FLOAT:
                case XfaElem.IMAGE:
                case XfaElem.LINE:
                case XfaElem.RECTANGLE:
                case XfaElem.TEXT:
                case XfaElem.TIME:
                    isOneOf = true;
                    break;
            }
            break;
        }
    }
    return isOneOf;
};

/**
 * Determines if the specified XFA element contains CDATA or PCDATA content. If it does, it means the node does not contain any XFA elements.
 * @param elemTag The XFA element to check for CDATA content.
 * @return True if the XFA element has CDATA content; false if not.
 */
XfaSchema.containsCData = function (elemTag) {
    var hasCData = false;
    switch (elemTag) {
        case XfaElem.APPEARANCEFILTER:
        case XfaElem.BOOLEAN:
        case XfaElem.CERTIFICATE:
        case XfaElem.DATE:
        case XfaElem.DATETIME:
        case XfaElem.DECIMAL:
        case XfaElem.DIGESTMETHOD:
        case XfaElem.ENCODING:
        case XfaElem.EXDATA:
        case XfaElem.FLOAT:
        case XfaElem.HANDLER:
        case XfaElem.IMAGE:
        case XfaElem.INTEGER:
        case XfaElem.LOCKDOCUMENT:
        case XfaElem.OID:
        case XfaElem.PICTURE:
        case XfaElem.REASON:
        case XfaElem.REF:
        case XfaElem.SCRIPT:
        case XfaElem.SPEAK:
        case XfaElem.SUBJECTDN:
        case XfaElem.TEXT:
        case XfaElem.TIME:
        case XfaElem.TOOLTIP:
            hasCData = true;
            break;
    }

    return hasCData;
};

/**
 * Returns the default value for XfaAtt.ALLOWRICHTEXT. Returns null if there isn't enough context.
 * @throws com.adobe.xfa.xfautil.Error Context node must be specified.
 * @throws com.adobe.xfa.xfautil.Error Attribute is not valid on the specified context node.
 */
XfaSchema._getAllowRichTextDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("Context node must be specified in order to determine " + XfaAtt.ALLOWRICHTEXT + " default.");
        return null;
    }

    if (contextNode.className != XfaElem.TEXTEDIT) {
        throw new Error(XfaAtt.ALLOWRICHTEXT + " is not a valid attribute on context node <" + contextNode.className + ">.");
        return null;
    }

    // Actual default depends on //value/{text|exData}

    // get <ui> node
    var parent = contextNode.parent;
    if (!parent) {
        return null;
    }

    // get field/draw node
    parent = parent.parent;
    if (!parent || (!(parent instanceof XfaField) && !(parent instanceof XfaDraw))) {
        return null;
    }

    if ((parent instanceof XfaField && parent.valueType == XfaElem.EXDATA) ||
        (parent instanceof XfaDraw && parent.valueType == XfaElem.EXDATA)) {
        return XfaSchema.ONE;
    }
    return XfaSchema.ZERO;
};

/**
 * Returns the default value for XfaAtt.CONTENTTYPE.
 * @throws com.adobe.xfa.xfautil.Error Context node must be specified.
 * @throws com.adobe.xfa.xfautil.Error Attribute is not valid on the specified context node.
 */
XfaSchema._getContentTypeDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("Context node must be specified in order to determine " + XfaAtt.CONTENTTYPE + " default.");
        return null;
    }

    switch (contextNode.className) {
        case XfaElem.EXDATA:
            return XfaMimeType.PLAINTEXT;
            break;

        case XfaElem.IMAGE:
            return XfaSchema.CDATA;
            break;

        case XfaElem.SCRIPT:
            return XfaVal.APPXFORMCALC;
            break;
    }

    throw new Error(XfaAtt.CONTENTTYPE + " is not a valid attribute on context node <" + contextNode.className + ">.");
    return null;
};

/**
 * Returns the default value for XfaAtt.INTACT.
 * @throws com.adobe.xfa.xfautil.Error Context node must be specified.
 * @throws com.adobe.xfa.xfautil.Error Attribute is not valid on the specified context node.
 */
XfaSchema._getIntactDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("Context node must be specified in order to determine " + XfaAtt.INTACT + " default.");
        return null;
    }

    if (contextNode.className != XfaElem.KEEP) {
        throw new Error(XfaAtt.INTACT + " is not a valid attribute on context node <" + contextNode.className + ">.");
        return null;
    }

    // From the XFA Schema: When the parent container is a subform and the subform's layout is flowing or table the default value is none.
    //  When the parent subform's layout is positioned or row the default value is contentArea. However when the parent container is a draw
    //  the default is always contentArea and when the parent is a field the default is always none.

    var parent = contextNode.parent;

    if (parent instanceof XfaSubform) {
        var layout = parent.getProperty(null, "@" + XfaAtt.LAYOUT);
        switch (layout) {
            case XfaVal.TB:
            case XfaVal.LRTB:
            case XfaVal.RLTB:
            case XfaVal.TABLE:
                return XfaVal.NONE;
                break;

            case XfaVal.POSITION:
            case XfaVal.ROW:
                return XfaVal.CONTENTAREA;
                break;

            default:
                // invalid layout attribute value
                break;
        }
    } else if (parent instanceof XfaField) {
        return XfaVal.NONE;
    } else if (parent instanceof XfaDraw) {
        return XfaVal.CONTENTAREA;
    }

    // unable to determine default from context node
    return null;
};

/**
 * Returns the default value for XfaAtt.MULTILINE.
 * @throws com.adobe.xfa.xfautil.Error Context node must be specified.
 * @throws com.adobe.xfa.xfautil.Error Attribute is not valid on the specified context node.
 */
XfaSchema._getMultiLineDefault = function (contextNode) {
    if (!contextNode) {
        throw new Error("Context node must be specified in order to determine " + XfaAtt.ALLOWRICHTEXT + " default.");
        return null;
    }

    if (contextNode.className != XfaElem.TEXTEDIT) {
        throw new Error(XfaAtt.MULTILINE + " is not a valid attribute on context node <" + contextNode.className + ">.");
        return null;
    }

    // One is the true default but actual default depends on //field vs //draw container element (see the spec).

    // get <ui> node
    var parent = contextNode.parent;
    if (!parent) {
        return null;
    }

    // get <field> or <draw> node
    parent = parent.parent;

    if (parent instanceof XfaField) {
        return XfaSchema.ZERO;
    } else if (parent instanceof XfaDraw) {
        return XfaSchema.ONE;
    }
    // unable to determine default from context node
    return null;
};

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var XmlUtil = ns.XmlUtil = {};

    XmlUtil.selectSingleNode = function (parent, localName, deep, occurrence) {
        deep = deep !== undefined ? deep : false;
        occurrence = isNaN(occurrence) ? 0 : occurrence;
        // Returns the first child node found with the given local name.
        var list = XmlUtil.selectNodes(parent, localName, deep);
        if (list && list.length() > occurrence) {
            return list[occurrence];
        } else {
            return null;
        }
    };
    XmlUtil.selectNodes = function (parent, localName, deep, attributeValue, attributeName, bExactMatch) {
        deep = deep !== undefined ? deep : false;
        attributeValue = attributeValue || null;
        attributeName = attributeName || "name";
        bExactMatch = bExactMatch !== undefined ? bExactMatch : true;
        if (parent == null) {
            return new XMLList();
        }
        var fullList;
        if (deep) {
            fullList = parent.descendants();
        } else {
            fullList = parent.elements();
        }

        return this.filterList(fullList, localName, attributeValue, attributeName, bExactMatch);
    };
    XmlUtil.filterList = function (fullList, localName, attributeValue, attributeName, bExactMatch) {
        attributeValue = attributeValue || null;
        attributeName = attributeName || "name";
        bExactMatch = bExactMatch !== undefined ? bExactMatch : true;
        var oList = new XMLList();

        for (var i = 0;
             i < fullList.length();
             i++) {
            var elem = fullList[i];
            if (localName == null || (elem.localName() != null && String(elem.localName()) == localName)) {
                // Element name matches - now check to see if an attribute needs to be matched as well.
                var bAdd = true;
                if (attributeValue) {
                    var attrMatch = XmlUtil.getAttribute(elem, attributeName);
                    if (!attrMatch) {
                        bAdd = false;
                    } else {
                        if (bExactMatch) {
                            if (attrMatch != attributeValue) {
                                //attribute values do not match
                                bAdd = false;
                            }
                        } else {
                            if (attrMatch.indexOf(attributeValue) == -1) {
                                //attribute value not found
                                bAdd = false;
                            }
                        }
                    }
                }
                if (bAdd) {
                    //add to list
                    oList.Append(elem);
                }
            }
        }
        return oList;
    };
    XmlUtil.getXmlObject = function (xmlobj, ignoreWhite, ignoreComments, ignorePIs) {
        ignoreWhite = ignoreWhite !== undefined ? ignoreWhite : false;
        ignoreComments = ignoreComments !== undefined ? ignoreComments : false;
        ignorePIs = ignorePIs !== undefined ? ignorePIs : false;
        var elem = null;

        if (!xmlobj) {
            return null;
        }

        if (xmlobj instanceof XMLList) {
            if (XMLList(xmlobj).length() > 0) {
                elem = xmlobj[0];
            }
        } else if (xmlobj instanceof XML) {
            elem = xmlobj;
        } else if (typeof xmlobj == "string") {
            // save settings
            var xmlSettings = XML.settings();

            // apply our own
            XML.ignoreWhitespace = ignoreWhite;
            XML.ignoreComments = ignoreComments;
            XML.ignoreProcessingInstructions = ignorePIs;

            try {
                elem = new XML(xmlobj);
            }
            catch (e) {
                //try wrapping with some root XML nodes
                try {
                    elem = new XML("<root>" + xmlobj + "</root>");
                } catch (e) {
                    //the string must contain incomplete XML so there
                    //is no way to convert it to an XML object
                    elem = null;
                }
            }

            // restore original settings
            XML.setSettings(xmlSettings);
        }

        return elem;
    };
    /**
     * Builds a path from a series of string arguments and calls selectNestedNode() with the resulting path.
     * <p>This is especially useful when you have string constants that you need to use instead of hardcoded
     *  strings. Typing <code>a,b,c</code> is much easier than typing <code>"/" + CONST_A + "/" + CONST_B + "/" + CONST_C</code>.
     *  With this function, you simply call <code>selectFromPath(parentXml, CONST_A, CONST_B, CONST_C);</code></p>
     * @param parentXml The element whose children and beyond will be searched.
     *  param arguments The string arguments that make-up the path. The result is in the form of <code>"/arg1/arg2/.../argN"</code>. Args
     *  names may be qualified with a namespace prefix as in <code>"prefix1:node1", "prefix2:node2", "node3"</code>.
     * @return An XML object representing the node referenced by the path or null if a match wasn't made.
     * @see #selectNestedNode()
     */
    XmlUtil.selectFromPath = function (parentXml) {
        parentXml = arguments[0];
        if (!parentXml) {
            return null;
        }

        var path = "";

        for (var i = 1;
             i < arguments.length;
             i++) {
            path += "/" + arguments[i].toString();
        }

        if (path) {
            return XmlUtil.selectNestedNode(parentXml, path);
        }

        return null;
    };
    XmlUtil.selectNestedNode = function (oParentElement, sPath) {
        if (oParentElement == null || sPath == null) {
            return null;
        }

        if (sPath.substr(0, 1) == "/") { // support optional leading "/"
            sPath = sPath.substr(1);
        }

        var toks = sPath.split("/");

        if (toks.length > 0) {
            var tok = toks[0]; // is either "name" or "prefix:name"

            var tokParts = tok.split(":"); // handle namespace prefix if specified
            var tokNsPrefix = (tokParts.length == 2 ? tokParts[0] : null);
            var tokName = (tokParts.length == 1 ? tokParts[0] : (tokParts.length == 2 ? tokParts[1] : null));
            if (null == tokName) {
                Debug.error("invalid token: " + tok);
                return null;
            }

            var elemList = oParentElement.elements();
            var item, i = 0;
            for (;
                i < elemList.length();
                i++) {
                item = elemList[i];
                if (item.localName() == tokName && (!tokNsPrefix || item.namespace(tokNsPrefix))) {
                    if (toks.length == 1) {
                        return item;
                    } else {
                        var oNode = XmlUtil.selectNestedNode(item, sPath.substring(sPath.indexOf(tok) + tok.length + 1));
                        if (oNode != null) {
                            return oNode;
                        }
                    }
                }
            }
            return null;
        }
        return null;
    };
    XmlUtil.decodeXmlChars = function (str, strict) {
        strict = strict !== undefined ? strict : false;
        if (str == null) {
            return null;
        }

        if (str.length == 0) {
            return "";
        }

        var dec = str; // the decoded string

        dec = dec.replace(new RegExp("&lt;", "g"), "<");
        dec = dec.replace(new RegExp("&gt;", "g"), ">");

        if (strict) {
            dec = dec.replace(new RegExp("&apos;", "g"), "'");
            dec = dec.replace(new RegExp("&quot;", "g"), "\"");
        }

        dec = dec.replace(new RegExp("&amp;", "g"), "&"); // do this *last* so that the ampersands in the previous codes don't get converted...
        return dec;
    };
    XmlUtil.encodeXmlChars = function (str, strict) {
        strict = strict !== undefined ? strict : false;
        if (str == null) {
            return null;
        }

        if (str.length == 0) {
            return "";
        }

        var enc = str; // encoded string

        enc = enc.replace(new RegExp("&", "g"), "&amp;"); // do this *first* so that the ampersands in the following inserted codes don't get converted...
        enc = enc.replace(new RegExp("<", "g"), "&lt;");
        enc = enc.replace(new RegExp(">", "g"), "&gt;");

        if (strict) {
            enc = enc.replace(new RegExp("'", "g"), "&apos;");
            enc = enc.replace(new RegExp('"', "g"), "&quot;");
        }

        return enc;
    };
    XmlUtil.getNodeText = function (xmlobj, deep, decode) {
        deep = deep !== undefined ? deep : true;
        decode = decode !== undefined ? decode : true;
        var node = XmlUtil.getXmlObject(xmlobj);

        if (!node) {
            if (typeof xmlobj == "string") {
                return decode ? XmlUtil.decodeXmlChars(String(xmlobj)) : String(xmlobj);
            } else {
                return "";
            }
        }

        if (node.hasSimpleContent()) {
            // always use XML.toString(), even if it decodes when we might not want it to, because it'll ensure that we get everything, including spaces,
            //  even if the content of the node is only whitespace
            var simpleContent = node.toString();
            if (!decode) {
                simpleContent = XmlUtil.encodeXmlChars(simpleContent);
            }

            return simpleContent;
        }

        //get all the node's children
        var childNode, sText = "";
        var list = node.children();

        for (var i = 0;
             i < list.length();
             i++) {
            childNode = list[i];
            switch (childNode.nodeKind()) {
                case XmlUtil.NODEKIND_TEXT :
                    sText += (decode ? childNode.toString() : childNode.toXMLString()); // XML.toString() decodes encoded XML characters
                    break;

                case XmlUtil.NODEKIND_ELEMENT :
                    if (deep) {
                        sText += XmlUtil.getNodeText(childNode, deep, decode); // recursive call
                    }
                    break;
            }
        }

        return sText;
    };

    XmlUtil.setNodeText = function (node, text, keepText, keepElements, keepComments, keepPIs) {

        keepText = keepText !== undefined ? keepText : false;
        keepElements = keepElements !== undefined ? keepElements : false;
        keepComments = keepComments !== undefined ? keepComments : false;
        keepPIs = keepPIs !== undefined ? keepPIs : false;
        if (!node) {
            return;
        }

        // Before assigning the new code, we have to extract all child elements we want to preserve
        //  otherwise they will be removed from the node's content. While they get removed from the
        //  content after setting the text, the nodes themselves don't get deleted (they just get
        //  de-referenced, I suppose) so they can easily be re-added as children.

        var content = keepText ? XmlUtil.getNodeText(node, false) : "";
        var elements = keepElements ? node.elements() : new XMLList();
        var comments = keepComments ? node.comments() : new XMLList();
        var pis = keepPIs ? node.processingInstructions() : new XMLList();

        // remove everything (same thing you would get if you used E4X to assign the text value to the node's content)
        XmlUtil.removeChildren(node);

        var xmlSettings = XML.settings();

        XML.ignoreWhitespace = false;
        XML.ignoreComments = false;
        XML.ignoreProcessingInstructions = false;

        // set the text content (in E4X, even though there are no children, you can still access the first child)
        if (null != text) {
            node.setChildren(content + text);
        }
        //node.children()[0] = content + text; // the XML class will automatically encode any XML characters in the text (except for apostrophes and quotation marks)

        var i, e, c, p;
        for (i = 0;
             i < elements.length();
             i++) {
            e = elements[i];
            node.appendChild(e, true);
        }
        for (i = 0;
             i < comments.length;
             i++) {
            c = comments[i];
            node.appendChild(c, true);
        }
        for (i = 0;
             i < pis.length;
             i++) {
            p = pis[i];
            node.appendChild(p, true);
        }

        XML.setSettings(xmlSettings);
    };
    XmlUtil.removeChildren = function (node) {
        XmlUtil.removeItems(node.children());
    };
    XmlUtil.removeNode = function (node) {
        if (!node) {
            return;
        }
        var nodeList = new XMLList(node);
        XmlUtil.removeItems(nodeList);
    };
    XmlUtil.removeItems = function (items) {
        var xmlList;
        if (items instanceof XML || items instanceof XMLList) {
            xmlList = items;
        }
        if (typeof items == "string") {
            xmlList = new XML(items);
        }
        if (xmlList) {
            for (var j = items.length() - 1;
                 j >= 0;
                 j--) {
                items.Delete(j);
            }
        }
    };
    XmlUtil.getParent = function (nodeXml) {
        return (nodeXml ? XmlUtil.getXmlObject(nodeXml.parent()) : null);
    };
    /**
     * Set an XML object's attribute value. The attribute will be removed
     * when the value is null.
     */
    XmlUtil.setAttribute = function (xmlobj, name, value) {
        if (!xmlobj || !name) {
            return;
        }

        var elem = XmlUtil.getXmlObject(xmlobj);
        if (elem != null) {
            if (value != null) {
                elem.Put('@' + name, value);
            } else {
                var list = elem.attribute(name);
                if (list && list.length() > 0) {
                    delete list[0];
                }
            }
        }
    };

    /**
     * Returns an XML object's attribute value. An empty string is returned if the attribute is not found unless an existence check is performed.
     * @param xmlobj
     * @param attrName Can be the local name (no namespace) only or a namespace qualifier may be specified (e.g. either "name" or "ns:name").
     * @param existenceCheck If true, null is returned when the attribute isn't specified (rather than an empty string).
     */
    XmlUtil.getAttribute = function (xmlobj, attrName, existenceCheck) {
        existenceCheck = existenceCheck !== undefined ? existenceCheck : false;
        var elem = XmlUtil.getXmlObject(xmlobj);

        if (elem && attrName) {
            var parts = attrName.split(":");
            var nsPrefix = (parts.length == 2 ? parts[0] : null);
            var localName = (parts.length == 1 ? parts[0] : (parts.length == 2 ? parts[1] : null));
            var attr, elementAttributes = elem.attributes();

            for (var index = 0;
                 index < elementAttributes.length();
                 index++) {
                attr = elementAttributes[index];
                if (attr.localName() == localName && (!nsPrefix || attr.inScopeNamespaces(nsPrefix))) {
                    // Attribute found
                    return attr.toString();
                }
            }
        }
        // Attribute not found
        return existenceCheck ? null : "";
    };
    XmlUtil.getPIXml = function (parent, domain, key, value) {
        value = value || null;
        if (!parent || !key || !domain) {
            return null;
        }

        var piList = parent.processingInstructions();
        var pi = null;

        for (var i = 0;
             i < piList.length;
             i++) {
            var piStr = piList[i].toString();
            var re = new RegExp(XmlUtil.PI_REGEXP, XmlUtil.PI_REGEXP_FLAGS);
            var matches = re.exec(piStr);

            //todo
            if (matches && matches.piDomain == domain && matches.piKey == key) {
                if (!value || matches.piValue == value) {
                    pi = piList[i];
                    break;
                }
            }
        }
        return pi;
    };

    XmlUtil.getPIXmlProperties = function (pi) {
        if (!pi) {
            return null;
        }

        var piStr = pi.toString();
        var re = new RegExp(XmlUtil.PI_REGEXP, XmlUtil.PI_REGEXP_FLAGS);
        var matches = re.exec(piStr);

        if (matches) {
            var props = {};
            props.domain = matches.piDomain;
            props.key = matches.piKey;
            if (matches.piValue) {
                props.value = matches.piValue;
            }
            return props;
        }
        return null;
    };

    /**
     * Searches the processing instructions on the specified node for a PI that has a matching domain and key. If a value is provided, the value will be matched as well.
     *  The search is case-sensitive.
     * @param parent XML node that contains the PIs to be searched.
     * @param pi Dynamic object with the following properties: "domain" (Required/String, the PI's domain), "key" (Required/String, the PI's key).
     * @param valueMatch Optional value to match as well. If specified, a &lt;?domain key valueMatch?&gt; PI must exist for the search to succeed. Specifying
     *  an empty string for this parameter will yield the same results as specifying null.
     * @return The PI's value (could be an empty string) if a matching PI was located, null otherwise.
     */
    XmlUtil.findPIObj = function (parent, pi, valueMatch) {
        valueMatch = valueMatch || null;
        if (!parent) {
            return null;
        }

        if (!pi.hasOwnProperty("domain") || !pi.hasOwnProperty("key")) {
            Debug.error("missing required properties in pi object: 'domain' and 'key'");
            return null;
        }

        var piXml = XmlUtil.getPIXml(parent, pi.domain, pi.key, valueMatch);
        if (piXml) {
            return XmlUtil.getPIXmlValue(piXml);
        }

        return null;
    };
    /**
     * Returns the value of a &lt;?domain key value?&gt; PI. The value may contain (or be) whitespace but the domain and key must not.
     * @param pi XML object representing the PI whose value is to be returned.
     * @return The PI's value as a string. If the PI doesn't have a value, an empty string is returned. If the PI doesn't have a domain and key, null is returned.
     */
    XmlUtil.getPIXmlValue = function (pi) {
        if (!pi) {
            return null;
        }
        var props = XmlUtil.getPIXmlProperties(pi);
        if (props) {
            return props.hasOwnProperty("value") ? props.value : "";
        }

        return null;
    };

    /**
     * Returns the value of a &lt;?domain key value?&gt; PI. The value may contain (or be) whitespace but the domain and key must not.
     * @param pi XML object representing the PI whose value is to be returned.
     * @return The PI's value as a string. If the PI doesn't have a value, an empty string is returned. If the PI doesn't have a domain and key, null is returned.
     */
    XmlUtil.getPIXmlValuefunction = function (pi) {
        if (!pi) {
            return null;
        }
        var props = XmlUtil.getPIXmlProperties(pi);
        if (props) {
            return props.hasOwnProperty("value") ? props.value : "";
        }

        return null;
    };

    /**
     * Determines the qualified name of the node (namespace <b>prefix</b> added if the node has a namespace). This differs from the QName object
     *  which prints URI::localName (prints the URI rather than the prefix and uses double colons rather than a single).
     * @param nodeXml The node whose qualified name is to be printed.
     * @return The qualified name (includes namespace prefix if node has namespace) or empty string if node is null or isn't an element or attribute.
     */
    XmlUtil.qualifiedName = function (nodeXml) {
        if (!nodeXml || (nodeXml.nodeKind() != XmlUtil.NODEKIND_ELEMENT && nodeXml.nodeKind() != XmlUtil.NODEKIND_ATTRIBUTE)) {
            return "";
        }

        var name = "";
        var ns = nodeXml.namespace();

        if (ns) {
            if (typeof ns.prefix == 'undefined') {
                // It seems that there are cases when an element or attribute may have a namespace prefix but the namespace isn't defined anywhere in the XML document.
                //  Strange but true. Perhaps it's OK when the namespace prefix is a well-know prefix like "xml" which is why the Namespace object, in that case,
                //  contains an undefined prefix but manages to produce a uri of "http://www.w3.org/XML/1998/namespace".
                // Example: In an XMP packet inside an XDP, you'll find <rdf:li xml:lang="x-default">{title}</rdf:li> where "xml" is not defined in the XDP doc.
                if (ns.uri == "http://www.w3.org/XML/1998/namespace") {
                    name += "xml:";
                }
            } else if (ns.prefix != "") {
                name += ns.prefix + ":";
            }
        }
        name += nodeXml.localName();
        return name;
    };

    /**
     * Prints the attributes specified on the XML node.
     * @param nodeXml The element whose attributes are to be printed.
     * @return The printed version of the XML node's attributes, all on a single line. If the node has no attributes, an empty string is returned.
     */
    XmlUtil._printXmlAttributes = function (nodeXml) {
        if (!nodeXml || nodeXml.nodeKind() != XmlUtil.NODEKIND_ELEMENT) {
            return "";
        }

        var print = "";
        var attList = nodeXml.attributes();

        for (var i = 0;
             i < attList.length();
             i++) {
            var attXml = attList[i];
            if (print.length > 0) {
                print += " ";
            }

            print += XmlUtil.qualifiedName(attXml);
            // strict=true in the following encoding function so that it encodes for all five characters (&,',",<,>)
            // This is necessary because toString() function decodes all five characters.
            var value = null;
            if (attXml) {
                if (typeof attXml.toXMLString === "function") {
                    value = attXml.toXMLString();
                } else {
                    value = attXml.toString();
                }
            }
            print += '="' + XmlUtil.encodeXmlChars(XmlUtil.decodeXmlChars(value, true), true) + '"';
        }
        return print;
    };

    /**
     * Prints an XML element.
     * @param nodeXml The element to print.
     * @param indentStr The indentation string to prepend to the printed output.
     * @param printOpen True if the opening of the element should be printed; false if the closing should be printed. If true and the node
     *  has no children, the node is printed as a closed element (e.g. &lt;elem/&gt;).
     * @return The printed version of the XML element. If the node is null, an empty string is returned.
     */
    XmlUtil._printXmlElement = function (nodeXml, indentStr, printOpen) {
        if (!nodeXml || nodeXml.nodeKind() != XmlUtil.NODEKIND_ELEMENT) {
            return "";
        }
        var print = "<";
        if (!printOpen) {
            print += "/";
        }
        // -- print the qualified name
        print += XmlUtil.qualifiedName(nodeXml);

        if (printOpen) {

            //Adding default namespace
            var ns = nodeXml._DefaultNamespace;
            if (ns && ns.uri && XmlUtil.qualifiedName(nodeXml) == "body") {
                print += " xmlns=\"" + ns.uri + "\" ";
            }

            // print the opening of the element
            // -- print the namespaces
            // this will list only new namespaces; in-scope namespaces will not be in this list
            var nsList = nodeXml.namespaceDeclarations();
            var nsScopeList = nodeXml.inScopeNamespaces();

            for (var i = 0;
                 i < nsList.length;
                 i++) {
                var ns = nsList[i];
                // add namespace declaration
                print += " xmlns";
                // check for default namespace
                if (ns.prefix != "") {
                    print += ":" + ns.prefix;
                }
                print += '="' + ns.uri + '"';
            }
            // -- print the attributes
            var atts = XmlUtil._printXmlAttributes(nodeXml);
            if (atts.length > 0) {
                print += " " + atts;
            }
            // -- postfix
            // if no children, close the node
            if (nodeXml.children().length() == 0) {
                print += "/";
            }
            print += ">";
        } else {
            // print the closing of the element
            print += ">";
        }
        return indentStr + print;
    };

    /**
     * Recursive helper function to XmlUtil.print().
     * @param nodeXml The XML node to print.
     * @param options Print options. Expected properties are as follows:
     *  <p>pretty: Boolean indicating whether to pretty-print or not.</p>
     *  <p>indent: int specifying the depth to indent when pretty-printing.</p>
     *  <p>level: int specifying the current level of recursion.</p>
     *  <p>filter: Function to call to filter nodes. Can be null.</p>
     * @return The printed version of the XML node (could be an empty string). Null if the node was filtered-out. Empty string if nodeXml was null.
     * @see #print()
     */
    XmlUtil._printXmlNode = function (nodeXml, options) {
        if (!nodeXml) {
            return "";
        }

        var print = "";
        var indentStr = options.pretty ? XmlUtil.repeat(XmlUtil._PRETTYPRINT_INDENT_CHAR, options.indent * options.level) : "";
        var prettyInside = options.pretty;
        var filterOptions = null;

        if (options.filter != null) {
            filterOptions = {prettyInside : prettyInside, keep : true};

            if (options.filter.call(null, nodeXml, filterOptions) == true) {
                if (!filterOptions.keep) {
                    return null;
                }
                prettyInside = filterOptions.prettyInside;
            } else {
                filterOptions = null;
            }
        }

        switch (nodeXml.nodeKind()) {
            case XmlUtil.NODEKIND_ELEMENT :
                // use this node's pretty setting
                print += ((print.length > 0 && options.pretty) ? "\n" : "") + XmlUtil._printXmlElement(nodeXml, indentStr, true);

                // use the children's pretty setting (prettyInside)
                if (nodeXml.children().length() > 0) {
                    if (nodeXml.children().length() == 1 && nodeXml.children()[0].nodeKind() == XmlUtil.NODEKIND_TEXT && filterOptions == null) {
                        // Override the pretty setting for children if there's only one, it's a text node and the filter function didn't explicitly
                        //  request that the contents of this node be pretty-printed.
                        // XML parsers typically output elements with a single text node all on a single line. This ensures that whitespace within text nodes remains intact.
                        // WARNING: Disabling this will lead to unexpected behaviour. For example, Designer crashes when "pasting the print-out into XML Source, going to Design
                        //  View and then back to XML Source" if this override is not applied.
                        prettyInside = false;
                    }

                    // Make a copy and apply settings for children on the copy since objects are passed by reference.
                    // WARNING: Do not use ObjectUtil.copy() because it won't copy the filter property for some reason (perhaps it only clones properties that are primitive types?).
                    var insideOptions = {pretty : prettyInside, indent : options.indent, level : options.level + 1, filter : options.filter};

                    var insidePrint = "";
                    var childElements = nodeXml.children();
                    for (var i = 0;
                         i < childElements.length();
                         i++) {
                        var child = childElements[i];
                        var childPrint = XmlUtil._printXmlNode(child, insideOptions); // recursive call
                        if (childPrint != null) {
                            insidePrint += ((insidePrint.length > 0 && prettyInside) ? "\n" : "") + childPrint;
                        }
                    }

                    // add the inside printed content (if any) to the print content, closing node the appropriate way
                    if (insidePrint.length > 0) {
                        // add inside content and close with </node> syntax
                        print += ((print.length > 0 && prettyInside) ? "\n" : "") + insidePrint;
                        print += ((print.length > 0 && prettyInside) ? "\n" : "") + XmlUtil._printXmlElement(nodeXml, prettyInside ? indentStr : "", false);
                    } else {
                        // no children were printed -- close with <node/> syntax
                        print = print.substring(0, print.length - 1) + "/>";
                    }
                }
                break;

            case XmlUtil.NODEKIND_ATTRIBUTE :
                Debug.warning("skipping attribute node '" + XmlUtil.qualifiedName(nodeXml) + "': these should be handled when printing elements", null);
                break;

            case XmlUtil.NODEKIND_COMMENT :
                print += ((print.length > 0 && options.pretty) ? "\n" : "") + XmlUtil._printXmlComment(nodeXml, indentStr);
                break;

            case XmlUtil.NODEKIND_PI :
                print += ((print.length > 0 && options.pretty) ? "\n" : "") + XmlUtil._printXmlPI(nodeXml, indentStr);
                break;

            case XmlUtil.NODEKIND_TEXT :
                print += ((print.length > 0 && options.pretty) ? "\n" : "") + XmlUtil._printXmlText(nodeXml, indentStr);
                break;

            default:
                Debug.warning("skipping unsupported node kind: " + nodeXml.nodeKind(), null);
                break;
        }
        return print;
    };

    /**
     * Prints an XML comment.
     * @param nodeXml The comment to print.
     * @param indentStr The indentation string to prepend to the printed output.
     * @return The printed version of the XML comment. If the node is null, an empty string is returned.
     */
    XmlUtil._printXmlComment = function (nodeXml, indentStr) {
        if (!nodeXml || nodeXml.nodeKind() != XmlUtil.NODEKIND_COMMENT) {
            return "";
        }

        // use toXMLString() to get the full mark-up
        var print = nodeXml.toXMLString();
        return indentStr + print;
    };
    /**
     * Prints an XML processing instruction.
     * @param nodeXml The processing instruction to print.
     * @param indentStr The indentation string to prepend to the printed output.
     * @return The printed version of the XML processing instruction. If the node is null, an empty string is returned.
     */
    XmlUtil._printXmlPI = function (nodeXml, indentStr) {
        if (!nodeXml || nodeXml.nodeKind() != NODEKIND_PI) {
            return "";
        }

        // use toXMLString() to get the full mark-up
        var print = nodeXml.toXMLString();
        return indentStr + print;
    };
    /**
     * Prints XML text.
     * @param nodeXml The text to print.
     * @param indentStr The indentation string to prepend to the printed output.
     * @return The printed version of the XML text. If the node is null, an empty string is returned.
     */
    XmlUtil._printXmlText = function (nodeXml, indentStr) {
        if (!nodeXml || !nodeXml.toString() || nodeXml.nodeKind() != XmlUtil.NODEKIND_TEXT) {
            return "";
        }

        // use toString() to get just the text, including spaces, then re-encode the text
        var print = XmlUtil.encodeXmlChars(nodeXml.toString());
        // fix-up cases where we have CRLF sequences since outputting those causes double-spaced text
        print = print.replace("\r\n", "\n");
        return indentStr + print;
    };
    /**
     * Finds the child element at the specified occurrence.
     * @param parentXml The parent XML node whose immediate children (only) will be searched.
     * @param elemName Class name of the child element sought.
     * @param occurrence The occurrence of the child element sought.
     * @param create If true and there are less existing occurrences of the specified child than the occurrence specified, the
     *  missing child elements will be created and appended to the parent node.
     * @return The child element sought (may be a new child of the parent if <code>create</code> was true). If <code>create</code> was false
     *  and the occurrence wasn't found, null.
     */
    XmlUtil.getChildOccurrence = function (parentXml, elemName, occurrence, create) {
        occurrence = occurrence !== undefined ? occurrence : 0;
        create = create !== undefined ? create : false;
        if (occurrence < 0) {
            return null;
        }

        var elemXml = null;

        var occur = -1; // current occurrence of existing elements with class names that match elemName
        var children = parentXml.elements();
        for (var i = 0;
             i < children.length();
             i++) {
            var childXml = children[i];
            if (childXml.localName() == elemName) {
                occur++;
                if (occur == occurrence) {
                    // found node sought
                    elemXml = childXml;
                    break;
                }
            }
        }

        if (!elemXml && create) {
            // add missing occurrences
            for (var j = 0;
                 j < (occurrence - occur);
                 j++) {
                elemXml = XmlUtil.addChildElement(parentXml, elemName);
            }
        }
        return elemXml;
    };
    /**
     * Returns a child element from its parent optionally creating and parenting it if it doesn't exist.
     * @param localnameOrIndex Can either be a string or a number.  When it's is a number an indexed search is performed otherwise the first element whose local
     *  name matches localnameOrIndex is returned.
     *  @param parent
     * @param create If true and the element is not found and localnameOrIndex is a string, a new element with localnameOrIndex as the local name is created and
     *  appended to the parent object.
     */
    XmlUtil.getChildElement = function (parent, localnameOrIndex, create) {
        create = create !== undefined ? create : false;
        var xmlParent = XmlUtil.getXmlObject(parent);

        if (!xmlParent) {
            return null;
        }

        var oNode = null;

        if (typeof localnameOrIndex == "number") {
            //Search by index
            var index = Number(localnameOrIndex);
            var children = xmlParent.elements();
            if (index < children.length() && index >= 0) {
                oNode = children[index];
            }
        } else {
            //Search by element name
            oNode = XmlUtil.selectSingleNode(xmlParent, localnameOrIndex);
            if (!oNode && create) {
                oNode = XmlUtil.addChildElement(xmlParent, localnameOrIndex);
            }
        }
        return oNode;
    };
    /**
     * Creates a new XML element with an optional name attribute and
     * appends it to the parent element.
     */
    XmlUtil.addChildElement = function (parent, elemName, name) {
        if (!parent || !elemName) {
            return null;
        }

        var oNode;
        if (name) {
            oNode = XmlUtil.createTag(elemName, {name : name});
        } else {
            oNode = XmlUtil.createTag(elemName, null);
        }
        parent.appendChild(oNode, true);
        return oNode;
    };
    XmlUtil.createTag = function (element, paramaters) {
        var name, xml, xmlString = "<" + element;
        if (paramaters) {
            for (name in
                paramaters) {
                xmlString += " " + name + "=\"" + paramaters[name] + "\"";
            }
        }
        xmlString += " />";
        xml = new XML(xmlString);
        return xml;
    };

    /**
     * Prints the specified XML node. This function differs from AS3's <code>XML.toXMLString()</code> function in that it has special handling for certain
     *  cases like unqualified namespace prefixes (where a namespace prefix is used when there's no definition for that prefix in the XML document). Whitespace,
     *  comments and processing instructions are always preserved.
     * @param rootXml The XML node to print.
     * @param options Optional object specifying the following optional properties:
     *  <p>pretty: Boolean. True if the printing should be pretty; false if it should be on a single line. Default: false.</p>
     *  <p>indent: int. The depth to indent new child lines when pretty-printing. Default: 2.</p>
     *  <p>filter: Function. Default: null. Function that is called prior to processing any type of node providing the ability to direct the algorithm on
     *   specific nodes. The function's signature is expected to be <code>function(node:XML, options:Object)</code> where node is the XML node about
     *   to be processed and options is a dynamic object used to pass in the current state and to pass out any state modifications. If the filter function
     *   returns true, the options will be considered, otherwise they will be ignored and the algorithm will continue its default processing. The options
     *   object has the following properties: <code>prettyInside</code> (Boolean set to the current state of <code>pretty</code>), <code>keep</code>
     *   (Boolean that defaults to true and determines whether the node should be included in the print-out or not). Default: null.</p>
     * @return The (pretty) printed version of the XML node. If rootXml is null, an empty string is returned.
     */
    XmlUtil.print = function (rootXml, options) {
        // There's a problem with the way the Flex XML class handles namespaces which aren't qualified. The output is valid but Designer 8.1+ crashes
        //  as a result of parsing it. Designer 8.2 will contain a fix for this.
        // In the XMP Metadata packet, the following node is defined:
        //  <rdf:li lang="x-default" xmlns="http://www.w3.org/XML/1998/namespace">
        // Defining this way results in invalid XML (at least most XML parsers don't like it). It's expecting it to be defined in this way:
        //  <rdf:li xml:lang="x-default">
        // (Notice that the Flex XML class is automatically qualifying the "xml" namespace with some default which the other parser doesn't like.)
        // This is one difference in the way this print function outputs the XML as opposed to how AS3's XML.toXMLString() does it.

        options = options || null;

        // initialize to default values
        var printOptions = {pretty : false, indent : 2, filter : null, level : 0};

        if (options) {
            if (options.hasOwnProperty("pretty")) {
                printOptions.pretty = options.pretty;
            }

            if (options.hasOwnProperty("indent")) {
                printOptions.indent = options.indent;
            }

            if (options.hasOwnProperty("filter")) {
                printOptions.filter = options.filter;
            }
        }

        var print = XmlUtil._printXmlNode(rootXml, printOptions);

        // always return a string
        return print ? print : "";
    };

    /** Returns a string whose content is the string c repeated count times. If c is null, the returned string is null. */
    XmlUtil.repeat = function (c, count) {
        var s = "";
        if (c == null) {
            return s;
        }
        for (var i = 0;
             i < count;
             i++) {
            s += c;
        }
        return s;
    };

    XmlUtil.getAllChildren = function (parentXML) {
        if (parentXML != null) {
            return parentXML._Children;
        }
    };

    XmlUtil.XHTMLNSURI = "http://www.w3.org/1999/xhtml";
    XmlUtil.NODEKIND_TEXT = "text";
    XmlUtil.NODEKIND_ELEMENT = "element";
    XmlUtil.NODEKIND_COMMENT = "comment";
    XmlUtil.NODEKIND_PI = "processing-instruction";
    XmlUtil.NODEKIND_ATTRIBUTE = "attribute";
    XmlUtil.PI_REGEXP = "<\\?(?P<piDomain>\\S+)\\s+(?P<piKey>\\S+)(?:\\s?)(?P<piValue>.*)\\?>";
    XmlUtil.PI_REGEXP_FLAGS = "gs";
    XmlUtil._PRETTYPRINT_INDENT_CHAR = " ";
})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2015. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var XfaUtil = ns.XfaUtil = {};

    /**
     * Prints the specified XFA node prodiving special handling for specific XFA nodes to preserve white space where it's needed (e.g. XHTML).
     * @param rootXfa The XFA XML node to print.
     * @param options Optional object specifying the following optional properties:
     *  <p>pretty: Boolean. True if the printing should be pretty; false if it should be on a single line. Default: false.</p>
     *  <p>indent: int. The depth to indent new child lines when pretty-printing. Default: 2.</p>
     * @return The (pretty) printed version of the XFA node. If rootXml is null, an empty string is returned.
     */
    XfaUtil.print = function (rootXfa, options) {
        var printOptions = {pretty : false, indent : 2, filter : this._printXfaFilter};
        if (options) {
            if (options.hasOwnProperty("pretty")) {
                printOptions.pretty = options.pretty;
            }
            if (options.hasOwnProperty("indent")) {
                printOptions.indent = options.indent;
            }
        }
        return ns.XmlUtil.print(rootXfa, printOptions);
    };

    XfaUtil._printXfaFilter = function (nodeXml, options) {
        var applyOptions = false;

        if (nodeXml && nodeXml.nodeKind() == ns.XmlUtil.NODEKIND_ELEMENT) {
            if (ns.XmlUtil.findPIObj(nodeXml, {domain : XfaUtil.PI_DOMAIN, key : "transientNode"}, null) != null) {
                // node is transient -- don't keep it
                options.keep = false;
                applyOptions = true;
            } else if (nodeXml.localName() == 'body') {
                var defaultNs = nodeXml.namespace();

                if (defaultNs && defaultNs.prefix == "" && defaultNs.uri == ns.XmlUtil.XHTMLNSURI && nodeXml.namespace('xfa') != 'undefined') {
                    // never pretty-print the XHTML
                    options.prettyInside = false;
                    applyOptions = true;
                }
            }
        }

        return applyOptions;
    };
    /**
     * Properly handles loading an XFA XML string into AS3's E4X XML object. XFA documents are usually pretty-printed which means whitespace must be ignored however
     *  they may contain some XHTML in which spaces must be preserved. AS3's XML object provides a way to ignore whitespace however it causes the whitespace within
     *  the XHTML to be ignored when it's critical to preserve it. This function handles the two different kinds of whitespace appropriately, making sure that the
     *  whitespace we don't want is discarded and the whitespace we do want is preserved.
     * @param sourceStr The string containing the (XFA) XML definition (may be an entire document (i.e. an XDP), a piece of XFA, or some arbitrary XML). Note that
     *  this even works with source strings which are not XML. If a non-XML source string is provided, the result will be an XML object with the string as its text
     *  (a text node, essentially, as per the top-level XML object's constructor output).
     * @return The XML object based on the specified string or null if an error occurred.
     */
    XfaUtil.load = function (sourceStr) {
        var xfaStr = sourceStr; // indirection simply to change the exposed parameter name without touching the code inside
        if (!xfaStr) {
            return null;
        }

        // space substitution character
        var spaceSubChar = 'x';

        //
        // Step 1: Replace each space in spaceruns with "x" characters.
        //
        var spacerunStyle = "xfa-spacerun : yes";
        var spacerunStart = '<span style="' + spacerunStyle + '">';
        var spacerunEnd = '</span>';

        // use global flag so we can iterate over matches using re.lastIndex as start for next search
        // handle extra whitespace in between element name and attribute on open and close tags
        var spacerunRE = XRegExp('/<\\s*?span\\s*?style="xfa-spacerun:yes"\\s*?>(\\s+)<\/\\s*?span\\s*?>/', 'gis');
        var spacerunMatch = spacerunRE.exec(xfaStr);
        var spacerunCount = 0;

        while (spacerunMatch) {
            spacerunCount++;
            // replace the spaces in the match with the same number of "x" characters
            xfaStr = xfaStr.substring(0, spacerunMatch.index) + spacerunStart + StringHelper.repeat(spaceSubChar, spacerunMatch[1].length) + spacerunEnd + xfaStr.substr(spacerunRE.lastIndex);
            // look for more matches
            spacerunMatch = spacerunRE.exec(xfaStr);
        }

        //
        // Step 2: Protect single spaces at the start and end of text nodes. These aren't marked as spaceruns (which contain 2 or more consecutive spaces or, in some exceptions,
        //         a single space, e.g. to indicate an empty paragraph) and they'll be removed when we load ignoring whitespace in the next step.
        //

        // this isn't an official style -- I just made this up hoping it's unique
        var singlerunStyle = spacerunStyle + ";loader-singlerun:yes";
        var singlerunStr = '<span style="' + singlerunStyle + '">' + spaceSubChar + '</span>';

        var singlerunRE = new RegExp();
        var bodyStartRE = XRegExp('<\\s*?body\\s.+?>', 'gis'); // handle whitespace before "body" and require 1 whitespace char after and then some content (namespaces) before closing '>'
        var bodyEndRE = XRegExp('<\/\\s*?body\\s*?>', 'gis'); // handle whitespace before and after "body"
        var bodyStartMatch = bodyStartRE.exec(xfaStr);
        var bodyEndMatch = bodyEndRE.exec(xfaStr);
        var singlerunCount = 0;

        while (bodyStartMatch && bodyEndMatch && bodyStartRE.lastIndex < bodyEndMatch.index) {
            // found a body node with contents
            // up to and including <body ...>
            var preBodyStr = xfaStr.substring(0, bodyStartRE.lastIndex);
            // content between <body ...> and </body>
            var contentStr = xfaStr.substring(bodyStartRE.lastIndex, bodyEndMatch.index);
            // </body> and the rest
            var postBodyStr = xfaStr.substr(bodyEndMatch.index);

            // space at start of text node
            var startRE = new RegExp('> \S', 'gi');

            // match single spaces at start of text nodes
            var startMatch = startRE.exec(contentStr);
            var spaceCounter = 0; // Count no. of space replaced
            while (startMatch) {
                singlerunCount++;
                spaceCounter++;
                // pattern will match one character preceding and one following the single space which must be preserved
                contentStr = contentStr.substring(0, startMatch.index + 1) + singlerunStr + contentStr.substr(startRE.lastIndex - 1);
                startMatch = startRE.exec(contentStr);
            }

            // space at end of text node
            var endRE = new RegExp('\S <', 'gi');

            // match single spaces at end of text nodes
            var endMatch = endRE.exec(contentStr);
            while (endMatch) {
                singlerunCount++;
                spaceCounter++;
                // pattern will match one character preceding and one following the single space which must be preserved
                contentStr = contentStr.substring(0, endMatch.index + 1) + singlerunStr + contentStr.substr(endRE.lastIndex - 1);
                endMatch = endRE.exec(contentStr);
            }
            // rebuild the XFA string with the new contents containing the substitutions
            xfaStr = preBodyStr + contentStr + postBodyStr;
            bodyStartRE.lastIndex += (spaceCounter * singlerunStr.length) - spaceCounter;
            bodyEndRE.lastIndex += (spaceCounter * singlerunStr.length) - spaceCounter;
            // look for more <body ...>...</body> matches
            bodyStartMatch = bodyStartRE.exec(xfaStr);
            bodyEndMatch = bodyEndRE.exec(xfaStr);
        }
        //
        // Step 3: Load the XFA ignoring whitespace.
        //
        // save current settings
        var xmlSettings = XML.settings();
        XML.ignoreComments = false;
        XML.ignoreProcessingInstructions = false;
        XML.ignoreWhitespace = true;
        var xfaXml = null;
        try {
            // Removing version details to resolve Error (Error : XML declaration allowed only at the start of the document)
            xfaStr = xfaStr.replace(/\s*\<\?xml.*?\?\>/i, "");
            // Replace all non-breakable space to space unicode in case of IE10 as ActiveX loadXml is failing in xbe4x
            if (ns.RTEUtils.isIE()) {
                xfaStr = xfaStr.replace(/\&nbsp\;/g, "&#160;");
            }
            xfaXml = new XML(xfaStr);
        }
        catch (err) {
            alert("exception " + err);
            // fail silently since caller may be testing string as being valid XML
        }
        // restore previous settings
        XML.setSettings(xmlSettings);
        //
        // Step 3: Restore the substituted spaces in the XML.
        var i;
        if (xfaXml) {
            var runXml = null;
            // restore spaceruns
            if (spacerunCount > 0) {
                var spacerunList = ns.XmlUtil.selectNodes(xfaXml, "span", true, spacerunStyle, "style", true);
                if (spacerunList.length() != spacerunCount) {
                    window.console.warn("found " + spacerunCount + " spacerun matches but found " + spacerunList.length() + " spacerun nodes", null);
                }

                for (i = 0;
                     i < spacerunList.length();
                     i++) {
                    runXml = spacerunList[i];
                    var text = ns.XmlUtil.getNodeText(runXml);
                    ns.XmlUtil.setNodeText(runXml, StringHelper.repeat(" ", text.length));
                }
            }

            // restore our custom "singleruns"
            if (singlerunCount > 0) {
                var singlerunList = ns.XmlUtil.selectNodes(xfaXml, "span", true, singlerunStyle, "style", true);
                if (singlerunList.length() != singlerunCount) {
                    window.console.warn("found " + singlerunCount + " singlerun matches but found only " + singlerunList.length() + " singlerun nodes", null);
                }

                var ignoreWhite = false;
                XML.ignoreWhitespace = false;
                // text node with a single space
                var singleXml = new XML("<span> </span>");
                // insert single space text node as a sibling of each singlerun node
                for (i = 0;
                     i < singlerunList.length();
                     i++) {
                    runXml = singlerunList[i];
                    var runParentXml = ns.XmlUtil.getParent(runXml);
                    if (runParentXml) {
                        runParentXml.insertChildAfter(runXml, singleXml);
                    }
                }
                // remove the singlerun node
                for (i = 0;
                     i < singlerunList.length();
                     i++) {
                    runXml = singlerunList[i];
                    let children = ns.XmlUtil.getAllChildren(runParentXml);
                    for (let j = children.length - 1; j >= 0 ; j--) {
                        if (children[j] != null && runXml === children[j]) {
                            delete children[j];
                        }
                    }
                }
                // remove all singleruns from the XML
                // ns.XmlUtil.removeItems(singlerunList);
                $(singlerunList).empty();

                // restore original whitespace flag
                XML.ignoreWhitespace = ignoreWhite;
            }
        }
        return xfaXml;
    };
    XfaUtil.getNodeText = function (xmlobj, deep, decode) {
        deep = deep !== undefined ? deep : true;
        decode = decode !== undefined ? decode : true;

        var node = this.getXmlObject(xmlobj);

        if (!node) {
            if (typeof xmlobj == "string") {
                return decode ? ns.XmlUtil.decodeXmlChars(String(xmlobj)) : String(xmlobj);
            } else {
                return "";
            }
        }

        if (node.hasSimpleContent()) {
            // always use XML.toString(), even if it decodes when we might not want it to, because it'll ensure that we get everything, including spaces,
            //  even if the content of the node is only whitespace
            var simpleContent = node.toString();
            if (!decode) {
                simpleContent = ns.XmlUtil.encodeXmlChars(simpleContent);
            }

            return simpleContent;
        }

        //get all the node's children
        var childNode, sText = "";
        var list = node.children();

        for (var i = 0;
             i < list.length;
             i++) {
            childNode = list[i];
            switch (childNode.nodeKind()) {
                case ns.XmlUtil.NODEKIND_TEXT:
                    sText += (decode ? childNode.toString() : childNode.toXMLString()); // XML.toString() decodes encoded XML characters
                    break;

                case ns.XmlUtil.NODEKIND_ELEMENT:
                    if (deep) {
                        sText += ns.XmlUtil.getNodeText(childNode, deep, decode); // recursive call
                    }
                    break;
            }
        }
        return sText;
    };

    XfaUtil.PI_DOMAIN = "xfalib";
    XfaUtil.NODEKIND_TEXT = "text";
    XfaUtil.NODEKIND_ELEMENT = "element";
    XfaUtil.NODEKIND_COMMENT = "comment";
    XfaUtil.NODEKIND_PI = "processing-instruction";
    XfaUtil.NODEKIND_ATTRIBUTE = "attribute";
    XfaUtil.PI_REGEXP = "<\\?(?P<piDomain>\\S+)\\s+(?P<piKey>\\S+)(?:\\s?)(?P<piValue>.*)\\?>";
    XfaUtil.PI_REGEXP_FLAGS = "gs";
    XfaUtil._PRETTYPRINT_INDENT_CHAR = " ";

})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var XfaRichTextUtil = ns.XfaRichTextUtil = function () {

        this.error = null;
    };

    /**
     * Tests the supplied string to determine if it only contains plain text and no XML elements, comments, processing instructions, etc.
     * @param value The string to test for plain text.
     * @return True if <code>value</code> is plain text; false if not.
     */
    XfaRichTextUtil.isPlainText = function (value) {
        var plain = ns.XmlUtil.getXmlObject(value);

        if (plain) {
            return (plain.nodeKind() == ns.XmlUtil.NODEKIND_TEXT);
        }
        return false;
    };

    /**
     * Tests the supplied string to determine if it is valid XFA rich text. All XFA rich text must be valid XML and have one of the following
     *  top-level container nodes:
     * <ul>
     * <li>exData -- only if includeExData is true (XFA node, in XML form, expected to contain rich text content)</li>
     * <li>html</li>
     * <li>body</li>
     * <li>p</li>
     * </ul>
     * @param value Can be either a String (which is converted to XML) or XML.
     * @param includeExData If true, &lt;exData&gt; XML nodes are considered as rich text.
     * @return True if the value is assumed to be (or contain, in the case of &lt;exData&gt;) rich text; false otherwise.
     */
    XfaRichTextUtil.isXfaRichText = function (value, includeExData) {
        includeExData = includeExData !== undefined ? includeExData : true;

        if (value == null || !(typeof value == "string" || value instanceof XML)) {
            return false;
        }

        var xfa = (value instanceof XML) ? value : ns.XfaUtil.load(value);

        if (xfa && xfa.nodeKind() == ns.XmlUtil.NODEKIND_ELEMENT) {
            if ((xfa.localName() == XfaElem.EXDATA && includeExData) ||
                xfa.localName() == "html" ||
                xfa.localName() == XfaXhtml.BODY || xfa.localName() == "p") {
                return true;
            }
        }
        return false;
    };

    /**
     * Creates an array of style objects form a given CSS string.
     * @param styleString The string to convert.
     * @return An array where each element is an object with the following dynamic properties:
     *  <ul>
     *   <li>styleName (String): The name of the style.</li>
     *   <li>styleValue (String): The value of the style.</li>
     *  </ul>
     */
    XfaRichTextUtil.createStyleArray = function (styleString) {
        if (!styleString) {
            return [];
        }

        var sStyleArray = styleString.split(";");
        var styleObjArray = [];

        for (var j = 0;
             j < sStyleArray.length;
             j++) {
            var sStyle = sStyleArray[j];
            // Skip empty style
            if (!sStyle) {
                continue;
            }

            var nameValue = sStyle.split(":");
            if (nameValue.length != 2) {
                window.console.warn(sStyle + " is not formatted correctly: skipped", null);
                continue;
            }
            var sStyleName = nameValue[0];
            var sStyleValue = nameValue[1];

            var oStyle = {};
            oStyle.styleName = sStyleName;
            oStyle.styleValue = sStyleValue;
            styleObjArray.push(oStyle);
        }
        return styleObjArray;
    };

    /**
     * Creates a new &lt;body .../&gt; element which is the container for XFA Rich Text.
     * @return The new &lt;body .../&gt; element as an XML object.
     */
    XfaRichTextUtil.createBodyElement = function () {
        // XHTML is the default namespace -- make sure you specify an empty string prefix otherwise later code that calls namespaceDeclarations()
        //  on this node will not see the default namespace!
        var nsXhtml = new Namespace("", XfaXhtml.XHTMLNSURI);
        var nsXfa = new Namespace(XfaSchema.XFANS, XfaData.XFADATANSURI);

        var xfaBody = ns.XmlUtil.createTag(XfaXhtml.BODY);
        xfaBody.setNamespace(nsXhtml);
        xfaBody.addNamespace(nsXfa);
        var attribute = new AttributeName(QName(nsXfa, "xfa:APIVersion"));
        xfaBody.Put("@xfa:APIVersion", XfaXhtml.AXTEAPIVERSION);

        return xfaBody;
    };

})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var PlainTextFormatter = ns.PlainTextFormatter = function () {

        this.error = null;
    };

    PlainTextFormatter.prototype.format = function (value) {
        if (this.error) {
            this.error = null;
        }

        if (!value || String(value).length == 0) {
            this.error = "Invalid value";
            return "";
        }
        return this.formatAsPlain(value);
    };

    PlainTextFormatter.prototype.formatAsPlain = function (value) {
        var inputText;

        if (value instanceof XML) {
            // assume this could be XFA and be careful with whitespace
            inputText = ns.XfaUtil.print(value);
        } else if (typeof value == "string") {
            // could be XFA Rich Text XML in string format or could be plain text
            inputText = value;
        } else {
            this.error = "Invalid type";
            return "";
        }

        if (ns.XfaRichTextUtil.isPlainText(inputText)) {
            // value is already formatted as plain text
            return inputText;
        }

        if (ns.XfaRichTextUtil.isXfaRichText(inputText)) {
            var xfaNode = ns.XfaUtil.load(inputText);
            var xfaPlainText = {};
            this.formatXfaPlainText(xfaNode, xfaPlainText);

            if (xfaPlainText.hasOwnProperty("error")) {
                this.error = xfaPlainText.error;
                return "";
            } else {
                return xfaPlainText.text;
            }
        }
        this.error = "Invalid value";
        return "";
    };
    /**
     * Takes a node representing XFA XHTML markup and converts it into plain text without any formating.
     * @param xfaNode [in] XML node representing XFA rich text markup.
     * @param result [out] Dynamic object which, upon return, has a "text" property containing the plain text string and,
     *  if an error occurred, an "error" property containing the error message.
     */
    PlainTextFormatter.prototype.formatXfaPlainText = function (xfaNode, result) {
        if (!xfaNode) {
            result.error = "Invalid XFA rich text markup";
            return;
        }

        var childXml, childList = xfaNode.children();

        for (var index = 0;
             index < childList.length();
             index++) {
            childXml = childList[index];
            if (childXml.nodeKind() == ns.XmlUtil.NODEKIND_ELEMENT) {
                var lookInside = true;
                var className = childXml.localName();

                switch (className.toUpperCase()) {
                    case "P":
                        this.convertParaTag(result);
                        break;

                    case "BR":
                        this.convertBreakTag(result);
                        break;

                    default:
                        break;
                }

                // make sure the conversions are OK
                if (result.hasOwnProperty("error")) {
                    return;
                }

                if (lookInside) {
                    this.formatXfaPlainText(childXml, result);
                    if (result.hasOwnProperty("error")) {
                        return;
                    }
                }
            } else if (childXml.nodeKind() == ns.XmlUtil.NODEKIND_TEXT) {
                if (result.hasOwnProperty("text")) {
                    result.text += ns.XmlUtil.getNodeText(childXml);
                } else {
                    result.text = ns.XmlUtil.getNodeText(childXml);
                }
            }
            // else, ignore attributes, PIs and comments
        }
    };

    /** Converts a &lt;p&gt; tag to plain text. Appends the result to the result object's "text" property. */
    PlainTextFormatter.prototype.convertParaTag = function (result) {
        // if it's not the very first paragraph, a paragraph equals two new lines
        if (result.hasOwnProperty("text")) {
            result.text += "\n\n";
        }
    };

    /** Converts a &lt;br&gt; tag to plain text. Appends the result to the result object's "text" property. */
    PlainTextFormatter.prototype.convertBreakTag = function (result) {
        // a line break is always equal to a single new line
        var newLine = "\n";

        if (result.hasOwnProperty("text")) {
            result.text += newLine;
        } else {
            result.text = newLine;
        }
    };
})(Form.rte.util);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    var HtmlUtils = ns.HtmlUtils = function () {
    };

    HtmlUtils.calculateHtmlPosition = function (htmlstr, pos) {
        // we return -1 (not found) if the position is bad
        if (pos <= -1) {
            return -1;
        }

        // characters that appears when a tag starts
        var openTags = ["<", "&"];
        // characters that appears when a tag ends
        var closeTags = [">", ";"];
        // the tag should be replaced with
        // ex: &amp; is & and has 1 as length but normal
        // tags have 0 length
        var tagReplaceLength = [0, 1];
        // flag to know when we are inside a tag
        var isInsideTag = false;
        var cnt = 0;
        // the id of the tag opening found
        var tagId = -1;
        var tagContent = "";

        for (var i = 0; i < htmlstr.length; i++) {
            // if the counter passes the position specified
            // means that we reach the text position
            if (cnt >= pos) {
                break;
            }
            // current char
            var currentChar = htmlstr.charAt(i);
            // checking if the current char is in the open tag array
            for (var j = 0; j < openTags.length; j++) {
                if (currentChar == openTags[j]) {
                    // set flag
                    isInsideTag = true;
                    // store the tag open id
                    tagId = j;
                }
            }
            if (!isInsideTag) {
                // increment the counter
                cnt++;
            } else {
                // store the tag content
                // needed afterwards to find new lines
                tagContent += currentChar;
            }
            if (currentChar == closeTags[tagId]) {
                // we ad the replace length
                if (tagId > -1) {
                    cnt += tagReplaceLength[tagId];
                }
                // if we encounter the </P> tag we increment the counter
                // because of new line character
                if (tagContent == "</P>") {
                    cnt++;
                }
                // set flag
                isInsideTag = false;
                // reset tag content
                tagContent = "";
            }
        }
        // return the position in html text
        return i;
    };

    /**
     * Given TLF Html Text, which means the string has the format <code>&lt;html&gt;&lt;body ...&gt;{HTML}&lt;/body&gt;&lt;/html&gt;</code>, remove
     *  the <code>&lt;html&gt;&lt;body&gt;</code> root element and return the content.
     * @param tlfHtml TLF exported Html.
     * @return The XHTML content of the TLF Text. If the provided string wasn't wrapped in the body element, the original
     *  string is returned.
     */
    HtmlUtils.extractXhtmlContent = function (tlfHtml) {
        if (!tlfHtml) {
            return tlfHtml;
        } // null or empty string

        var RegExpr = XRegExp('^<HTML><BODY[^>]*>\\s*(.*)\\s*<\/BODY><\/HTML>', "gis");
        var result = RegExpr.exec(tlfHtml);
        if (result) {
            return result[1];
        }

        return tlfHtml;
    };
    HtmlUtils.searchBackwards = function (source, searchText, indexPosition) {
        for (var i = indexPosition; i >= 0; i--) {
            var index = source.indexOf(searchText, i);
            if (index == i) {
                return i;
            }
        }
        return -1;
    };

    HtmlUtils.searchForward = function (source, searchText, indexPosition) {
        for (var i = indexPosition; i < source.length; i++) {
            var index = source.indexOf(searchText, i);
            if (index == i) {
                return i;
            }
        }
        return -1;
    };

    /**
     * Converts HTML to XFA XHTML.
     * @param str HTML text to convert.
     * @return XFA XHTML equivalent as a <code>String</code>. Note that while the string contains XML, it will be a series of elements without
     *  a root node which means it should be wrapped in a root node in order to load it as valid XML.
     */

    HtmlUtils.richTextEditorToHtml = function (str, config) {
        var xmlSettings = XML.settings();
        XML.prettyPrinting = false;
        XML.ignoreWhitespace = false;

        //Remove the "<html><body>" wrapper tags that might have been introduced due to TLF exported html.
        str = HtmlUtils.extractXhtmlContent(str);

        // Code to convert <br> </br> to <br/> as otherwise it gets converted to <br> <br> by innerHTML
        var pattern = new RegExp('<br><\/br>', 'gi');
        str = str.replace(pattern, "<br/>");

        // Create XML document
        var XMLObj = document.createElement("BODY");
        XMLObj.innerHTML = str;
        // temporary
        var t1;
        var t2;
        // remove the TABSTOPS Attribute
        //var elements = $(xmlObj);
        $(XMLObj).find('*').removeAttr('TABSTOPS');

        // remove the TARGET Attribute Except for Anchor tag
        //var elements = $(xmlObj);
        $(XMLObj).find('*').not("a").removeAttr('TARGET');

        // Find the TEXTFORMAT LEADING Attribute
        $(XMLObj).find('*[LEADING]').each(function () {
            var t2 = $(this);
            var leading = parseFloat(t2.attr("leading"));
            var t3;
            var t4;
            var t5;
            $(t2).find('P').each(function () {
                t4 = $(this);
                var size = parseFloat(leading);
                $(t4).find('FONT').each(function () {
                    t5 = $(this);
                    if (t5 != null && t5.length > 0) {
                        var fontSize = parseFloat(t5.attr("SIZE"));
                        if ((fontSize + leading) > size) {
                            size = fontSize + leading;
                        }
                    }
                });
                var style1 = $(t4).attr("style");
                if (style1 != undefined) {
                    //removing the old line-height if exists to update with new line-height
                    //as currently new line-height is appended to style but not honoured because of old line-height still present
                    var reg = /(line-height:.*?pt;)/gi;
                    style1 = style1.replace(reg, "");
                }
                $(t4).attr('style', 'line-height:' + size + 'pt;' + ((typeof style1 == 'undefined') ? '' : style1));
            });
            $(t2).removeAttr('LEADING');
        });

        // Find all LEFTMARGIN in TEXTFORMAT
        $(XMLObj).find('*[LEFTMARGIN]').each(function () {
            var t2 = $(this);
            var leftMargin = parseFloat(t2.attr('LEFTMARGIN'));
            $(t2).find('P').each(function () {
                var t4 = (this);
                var style = t4.attr('style');
                t4.attr('style', 'margin-left: ' + leftMargin + 'pt;' + ((typeof style == 'undefined') ? '' : style));
            });
            $(t2).removeAttr('LEFTMARGIN');
        });

        // Find all INDENT in TEXTFORMAt
        $(XMLObj).find('*[INDENT]').each(function () {
            var t2 = $(this);
            var indent = parseFloat(t2.attr('INDENT'));
            $(t2).find('P').each(function () {
                var t4 = $(this);
                var style = t4.attr('style');
                //  alert("style1 indent"+style);
                t4.attr('style', 'text-indent: ' + indent + 'pt;' + ((typeof style == 'undefined') ? '' : style));
                //alert($(t4).attr('style'));
            });
            $(t2).removeAttr('INDENT');
        });

        // Find all ALIGN
        $(XMLObj).find('*[ALIGN]').each(function () {
            var t2 = $(this);
            var align = t2.attr('ALIGN');
            var style = t2.attr('style');
            //alert("style1 align"+style);
            t2.attr('style', 'text-align: ' + align + ';' + ((typeof style == 'undefined') ? '' : style));
            //alert($(t2).attr('style'));
            $(t2).removeAttr('ALIGN');
        });

        // Find all FACE
        $(XMLObj).find('*[FACE]').each(function () {
            var t2 = $(this);
            var face = t2.attr('FACE');
            var style = t2.attr('style');
            //  alert("style1 face"+style);
            t2.attr('style', 'font-family: ' + face + ';' + ((typeof style == 'undefined') ? '' : style));
            //	alert($(t2).attr('style'));
            $(t2).removeAttr('FACE');
        });
        // Find all SIZE
        $(XMLObj).find('*[SIZE]').each(function () {
            var t2 = $(this);
            var size = parseFloat(t2.attr('SIZE'));
            var style = t2.attr('style');
            //alert("style1 size"+style);
            t2.attr('style', 'font-size: ' + size + 'pt;' + ((typeof style == 'undefined') ? '' : style));
            //alert($(t2).attr('style'));
            $(t2).removeAttr('SIZE');
        });

        // Find all COLOR
        $(XMLObj).find('*[COLOR]').each(function () {
            var t2 = $(this);
            var color = t2.attr('COLOR');
            var style = t2.attr('style');
            //alert("style1 color "+style);
            t2.attr('style', 'color: ' + color + ';' + ((typeof style == 'undefined') ? '' : style));
            //alert($(t2).attr('style'));
            $(t2).removeAttr('COLOR');
        });
        // Find all LETTERSPACING
        $(XMLObj).find('*[LETTERSPACING]').each(function () {
            var t2 = $(this);
            var letterSpacing = t2.attr('LETTERSPACING');
            var style = t2.attr('style');
            //alert("style1 letterSpacing "+style);
            t2.attr('style', 'letter-spacing: ' + letterSpacing + 'pt;' + ((typeof style == 'undefined') ? '' : style));
            //alert($(t2).attr('style'));
            $(t2).removeAttr('LETTERSPACING');
        });
        // Find all KERNING
        $(XMLObj).find('*[KERNING]').each(function () {
            var t2 = $(this);

            $(t2).removeAttr('KERNING');
        });

        var cleanHtml = this.cleanHTML(XMLObj.innerHTML, config);

        XML.setSettings(xmlSettings); // restore original settings
        return cleanHtml;
    };
    HtmlUtils.wrapInBody = function (html) {
        if (html.match(/<body[^>]*>[\s\S]*<\/body>/gi) == null) {
            html = '<body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/" xfa:APIVersion="2.7.0.0">' + html + '</body>';
        }
        return html;
    };

    /**
     * Given a string with the format <body ...>{XHTML}</body>, remove the <body> root element and surrounding whitespace and return the content
     * @param html
     */
    HtmlUtils.extractBodyContent = function (html) {
        if (!html) {
            return "";
        }
        // given a string with the format <body ...>{XHTML}</body>, remove the <body> root element and surrounding whitespace and return the content
        var re = XRegExp("^\\s*<body[^>]*>\\s*(.*)\\s*<\/body>\\s*$", "gs");
        var result = re.exec(html); // will return null if the body node is <body .../>

        var content = "";
        if (result != null && result.length > 1) {
            content = result[1];
        }

        return content;
    };

    /**
     * Formats the Rich Text and adds all content inside <p><span></span></p>
     * @param str
     * @returns returns the formatted string
     */
    HtmlUtils.cleanRichText = function (str, config) {

        //Replace Div's with para tag
        var pattern = new RegExp('<div', 'gi');
        str = str.replace(pattern, '<p');

        pattern = new RegExp('</div>', 'gi');
        str = str.replace(pattern, '</p>');

        //Move all outside content after </p> inside p > span
        pattern = new RegExp('\/p>([^<]+|<br></br>)(<p|[^<]*$)', 'gi');
        str = str.replace(pattern, "\/p><p><span>$1</span><\/p>$2");

        //Move all outside content before <p> inside p > span
        pattern = new RegExp('(^[^<]+|<br></br>)(<p|[^<]*$)', 'i');
        str = str.replace(pattern, "<p><span>$1</span><\/p>$2");

        //Move para content without any span within span
        pattern = new RegExp('(<p[^<]*>)(((?!((<span)|(<\/p>))).)*)<\/p>','gi');
        str = str.replace(pattern, "$1<span>$2<\/span><\/p>");

        // empty lines will get lost if they don't contain at least one space
        // an empty line will may look like <p ...><span ...><span ...></span ...></span ...></p> so replace it with <p ...><span ...><span ...></span ...></span ...></p>
        //(at least one span should have single space as content)
        //  so that when we add 'xfa-spacerun:yes' to all span styles (later), the space is retained and the Adobe Text Engine renders the empty line

        pattern = new RegExp('<p([^>]*)>(.*?)<\/p>', 'gi');
        str = str.replace(pattern, HtmlUtils.convertEmptyParaToXhtml);

        //Remove Empty Para
        pattern = new RegExp('<p([^>]*)><\/p>', 'gi');
        str = str.replace(pattern, '');

        //Add default styles to li already containing style attribute
        pattern = new RegExp('<li([^<]*) style="([^<"]*)"([^<]*)>', 'gi');
        var result = pattern.exec(str);
        while (result && result.length > 3) {
            str = str.replace(result[0], '<li' + result[1] + ' style="' + HtmlUtils.getMissingParaStyle(result[2], config) + '"' + result[3] + '>');
            result = pattern.exec(str);
        }

        //Add default style to li
        pattern = new RegExp('<li(((?!style=")[^>])*)>', 'gi');
        str = str.replace(pattern, '<li style="' + HtmlUtils.getDefaultParaStyle(config) + '">');

        //Replacing all para inside li to temp tag to avoid default style to be added.
        pattern = new RegExp('<li([^>]*)>([^<]*)<p([^>]*)>(((?!<p).)*)</p>', 'gi');
        str = str.replace(pattern, '<li$1>$2<temp$3>$4</temp>');

        //Add default styles to para already containing style attribute
        pattern = new RegExp('<p([^<]*) style="([^<"]*)"([^<]*)>', 'gi');
        var result = pattern.exec(str);
        while (result && result.length > 3) {
            str = str.replace(result[0], '<p' + result[1] + ' style="' + HtmlUtils.getMissingParaStyle(result[2], config) + '"' + result[3] + '>');
            result = pattern.exec(str);
        }

        //Add default style to para
        pattern = new RegExp('<p(((?!style=")[^>])*)>', 'gi');
        str = str.replace(pattern, '<p style="' + HtmlUtils.getDefaultParaStyle(config) + '">');

        //Changing temp tag back to para
        pattern = new RegExp('<temp([^>]*)>(((?!<temp).)*)</temp>', 'gi');
        str = str.replace(pattern, '<p$1>$2</p>');

        return str;
    };

    /**
     * Cleans an already somewhat formatted XHTML string converted from HTML.
     * @param str Partially-converted XFA XHTML content from HTML source. The string is expected to contain multiple
     *  elements without a root node.
     * @return XFA XHTML content, fully-converted, containing multiple elements without a root node.
     */
    HtmlUtils.cleanHTML = function (str, config) {

        if (str == "") {
            return str;
        }

        //TODO: Why we need to replace these. Then we should correct the regex
        /* replace all empty lines that are formatted with bullet style
         var pattern:RegExp = /(<TEXTFORMAT.*?>)?<LI><FONT\s[^>]*?\/?>(<(B|I|U)>)*?(<\/(B|I|U)>)*?(<\/FONT>)?<\/LI>(<\/TEXTFORMAT>)?/ig;
         var str:String = string.replace(pattern, "<p/>"); */
        // format <indent> tag

        var pattern = new RegExp('TEXTFORMAT', "gi");

        str = str.replace(pattern, "SPAN");
        pattern = new RegExp('COLOR=\"(.*?)\"', 'gi');

        str = str.replace(pattern, "color:$1;");
        pattern = new RegExp('SIZE=\"(.*?)\"', 'gi');

        str = str.replace(pattern, "font-size:$1pt;");
        pattern = new RegExp('FACE="(.*?)\"/', 'gi');

        str = str.replace(pattern, "font-family:$1;");
        pattern = new RegExp('ALIGN=\"(.*?)\"', 'gi');

        str = str.replace(pattern, "text-align:$1;");

        // format <indent> tag
        pattern = new RegExp('INDENT=\"(.*?)\"', 'gi');
        str = str.replace(pattern, "text-indent:$1;");

        //format <font> tag
        pattern = new RegExp('<FONT STYLE', 'gi');
        str = str.replace(pattern, "<span style");

        pattern = new RegExp('<FONT>', 'gi');
        str = str.replace(pattern, "<span>");

        pattern = new RegExp('<\/FONT>', 'gi');
        str = str.replace(pattern, "<\/span>");

        //LK: replace empty <FONT/> tags
        pattern = new RegExp('<FONT\/>', 'gi');
        str = str.replace(pattern, "");

        //format <p> tag
        pattern = new RegExp('<P STYLE', 'gi');
        str = str.replace(pattern, "<p style");

        pattern = new RegExp('<\/P>', 'gi');
        str = str.replace(pattern, "<\/p>");

        //format <a> tag
        pattern = new RegExp('<A HREF', 'gi');
        str = str.replace(pattern, "<a href");

        pattern = new RegExp('<\/A>', 'gi');
        str = str.replace(pattern, "<\/a>");

        //format <span> tag
        pattern = new RegExp('<SPAN STYLE', 'gi');
        str = str.replace(pattern, "<span style");

        pattern = new RegExp('<SPAN', 'gi');
        str = str.replace(pattern, "<span");

        pattern = new RegExp('<\/SPAN>', 'gi');
        str = str.replace(pattern, "<\/span>");

        var pattern = new RegExp('<br>(?!<\/br>)', 'gi');
        str = str.replace(pattern, "<br><\/br>");

        // remove any bullets we might find since we don't support bulleting in a text module
        // pattern = /<LI>/gi;
        // var bulletFormat:String = "<p>";
        // str = str.replace(pattern, bulletFormat);
        // pattern= /<\/LI>/gi;
        // str = str.replace(pattern, "</p>");

        //TODO: count connected \t occurrences and add only one span tag with the right tab-count property
        //replace all \t escape characters with \t and xfa tab since \t is not honoured while previewing letter in CCR
        // and xfa tab is not honoured in HTML text editor.
        pattern = new RegExp('\t(?!(<span style="xfa-tab-count:1"><\/span>))', 'g');
        str = str.replace(pattern, "\t<span style=\"xfa-tab-count:1\"></span>");

        //do Variable replacement
        pattern = new RegExp('(\{\$(.*?)\$\})', 'gi');
        str = str.replace(pattern, "<span xfa:embedType=\"uri\" xfa:embedMode=\"raw\" xfa:embed=\"$2\">$1</span>");

        // format <ul> tag -- we don't support lists, so remove these tags since each list item we may have found will now be its own paragraph
        // pattern= /<UL>/gi;
        // str = str.replace(pattern, "");
        // pattern= /<\/UL>/gi;
        // str = str.replace(pattern, "");
        // format <ol> tag -- we don't support lists, so remove these tags since each list item we may have found will now be its own paragraph
        // pattern= /<OL>/gi;
        // str = str.replace(pattern, "");
        // pattern= /<\/OL>/gi;
        // str = str.replace(pattern, "");

        //format alignment in styles tag
        pattern = new RegExp('text-align: RIGHT', 'gi');
        str = str.replace(pattern, "text-align: right");

        pattern = new RegExp('text-align: LEFT', 'gi');
        str = str.replace(pattern, "text-align: left");

        pattern = new RegExp('text-align: CENTER', 'gi');
        str = str.replace(pattern, "text-align: center");

        pattern = new RegExp('text-align: JUSTIFY', 'gi');
        str = str.replace(pattern, "text-align: justify");

        //this is to fix a bug
        //for some reason there is a U/B/I/ tag showing up?

        pattern = new RegExp('<U\/>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<U><\/U>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<U><br></U>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<U><br><\/br></U>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<B\/>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<B><\/B>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<B><br></B>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<B><br><\/br></B>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<I\/>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<I><\/I>', 'gi');
        str = str.replace(pattern, "");

        pattern = new RegExp('<I><br></I>', 'gi');
        str = str.replace(pattern, "<br></br>");

        pattern = new RegExp('<I><br><\/br></I>', 'gi');
        str = str.replace(pattern, "<br></br>");

        //LK: p in span should not happen...
        pattern = new RegExp('<span>\s*<p ', 'gi');
        str = str.replace(pattern, "<p ");

        pattern = new RegExp('<\/p>\s*<\/span>', 'gi');
        str = str.replace(pattern, "</p>");

        //LK avoid blanks at beginning of lines
        // we need to assemble span tags
        //pattern = /<span style="([^"]*)">[^<]*<span style="([^"]*)">([^<]*)<\/span>\s*<\/span>/gi;
        //SST 09.05.08 : Assemble span tags in case there is no other text between the span tags

        pattern = new RegExp('<span style="([^"]*)"><span style="([^"]*)">([^<]*)<\/span>\s*<\/span>', 'gi');
        str = str.replace(pattern, HtmlUtils.mergeXhtmlSpanStyles);
        str = str.replace(pattern, HtmlUtils.mergeXhtmlSpanStyles);
        str = str.replace(pattern, HtmlUtils.mergeXhtmlSpanStyles);

        // Replace multiple spaces with &#160;
        pattern = new RegExp('  ', 'g');
        str = str.replace(pattern, "&#160;&#160;");

        // replacing all &nbsp; to &#160;
        pattern = new RegExp('&nbsp;', 'g');
        str = str.replace(pattern, "&#160;");

        str = HtmlUtils.cleanRichText(str, config);

        //next all spans with xfa-spacerun:yes:
        //pattern = new RegExp('<span style="([^"]*)">','gi');
        //str = str.replace(pattern, "<span style=\"$1; xfa-spacerun:yes\">");
        //Spaces between the tags will get lost if they don't own Spans
        //Moving tabs/white-spaces outside html tags inside span tag
        pattern = new RegExp('>([ \t]+)<?!(\/)', 'gi');
        str = str.replace(pattern, "><span style=\"xfa-spacerun:yes\">$1</span><");

        //LK: Formatting of variables must be chosen, otherwise it will be lost when replacing
        //    the variables by its value
        pattern = new RegExp('<span xfa:embedType="uri" xfa:embedMode="raw" xfa:embed="([^"]*)">\s*<span style=([^>]*)>([^<]*)<\/span>\s*<\/span>', 'gi');
        str = str.replace(pattern, "<span style=$2><span xfa:embedType=\"uri\" xfa:embedMode=\"raw\" xfa:embed=\"$1\">$3</span></span>");

        return str;
    };

    /**
     * This function is used as replacement function to assemble span tags in case there is no other text between the span tags
     * pattern = /<span style="([^"]*)">[^<]*<span style="([^"]*)">([^<]*)<\/span>\s*<\/span>/gi;
     * param arguments
     * @return
     *
     */
    HtmlUtils.mergeXhtmlSpanStyles = function () {

        //There should be three groups in matched strings: outer span styles, inner span styles, inner span contents. If that's not the case, return the original string

        if (arguments.length != 6) {
            return arguments[0];
        }

        var outerStylesStr = arguments[1];
        var innerStyles = arguments[2];
        var spanContent = arguments[3];

        var margedStyles = (innerStyles != null) ? innerStyles : "";
        var outerStyles = outerStylesStr.split(";");

        for (var i = 0; i < outerStyles.length; i++) {
            var outerStyle = outerStyles[i];
            if (outerStyle.indexOf(":") > 0) {
                var styleName = outerStyle.substring(0, outerStyle.indexOf(":"));
                styleName = styleName.trim();
                if (margedStyles.toLowerCase().indexOf(styleName.toLowerCase()) < 0) {
                    margedStyles = margedStyles + "; " + outerStyle.trim();
                }
            }
        }
        return "<span style=\"" + margedStyles + "\">" + spanContent + "</span>";
    };

    /**
     * Handles the paragraph that does not have any content to insert a empty space so that can be used with space run
     * to show new lines in xfa for empty para.
     * Note: this does not explicitly adds xfa-spacerun to span tags
     * param arguments
     * @return
     */

    HtmlUtils.convertEmptyParaToXhtml = function () {
        var str = String(arguments[0]);
        var plainTextFormatter = new ns.PlainTextFormatter();
        var plainText = plainTextFormatter.format(str);
        //if(!(plainText) && !(error)){
        if (!(plainText)) {
            var str1 = str;
            //Handle both expanded and non expanded span.

            var pattern = new RegExp('<span([^>]*)\/>', 'i');
            str = str.replace(pattern, "<span$1> </span>");

            pattern = new RegExp('<span([^>]*)\><\/span>', 'i');
            str = str.replace(pattern, "<span$1> </span>");

            pattern = new RegExp('<span([^>]*)>[\s ]*</span>', 'i');
            str = str.replace(pattern, "<span$1><br></br></span>");

        }

        return str;
    };

    HtmlUtils.getDefaultParaStyle = function (config) {
        var style = "";
        if (config) {
            style += 'font-family:' + config.fontFamily.defaultValue + ';';
            style += 'font-size:' + config.fontSize.defaultValue + 'pt;';
            style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'pt;';
            style += 'color:#000000;';
            style += 'text-align:left;';
        }

        return style;
    };

    HtmlUtils.getMissingParaStyle = function (style, config) {
        if (style && style.length > 0) {
            if (config) {
                if (!ns.StringHelper.endsWith(style, ";")) {
                    style += ";";
                }
                if (style.indexOf("font-family") < 0) {
                    style += 'font-family:' + config.fontFamily.defaultValue + ';';
                }
                if (style.indexOf("font-size") < 0) {
                    style += 'font-size:' + config.fontSize.defaultValue + 'pt;';
                }
                if (style.indexOf("letter-spacing") < 0) {
                    style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'pt;';
                }
                if (style.indexOf("color") < 0) {
                    style += 'color:#000000;';
                }
                if (style.indexOf("text-align") < 0) {
                    style += 'text-align:left;';
                }
            }
        } else {
            style = HtmlUtils.getDefaultParaStyle(config);
        }
        return style;
    };

})(Form.rte.util);

(function () {
// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/button.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1, helper;

  return "<button class=\"rte-button rte-button-quiet "
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + " "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + " "
    + ((stack1 = helpers["if"].call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.selected : depth0),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "")
    + "\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-statecallbackfn=\"Form.rte.CommandStateCallbacks.setButtonState\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" type=\"button\" name=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-value=\""
    + container.escapeExpression(((helper = (helper = helpers.value || (depth0 != null ? depth0.value : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"value","hash":{},"data":data}) : helper)))
    + "\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\" href=\"javascript:;\" unselectable=\"on\">\n    <span class=\"icon-"
    + container.escapeExpression(((helper = (helper = helpers.icon || (depth0 != null ? depth0.icon : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"icon","hash":{},"data":data}) : helper)))
    + "\" aria-hidden=\"true\"></span>\n    "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.text : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\n</button>";
},"1":function(container,depth0,helpers,partials,data) {
    return "active";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['button'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['button'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/colorInput.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var helper;

  return "<div class=\"rte-colorInput "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\">\n    <span>"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.label : depth0),{"name":"I18n","hash":{},"data":data}))
    + "</span>\n    <input class=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + " rte-colorInput-control\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-stateCallbackFn=\"Form.rte.CommandStateCallbacks.setColorInputValue\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-skip>\n</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['colorInput'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['colorInput'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/findAndReplace.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    return "<form class=\"rte_findAndReplace_dialog\">\n    <input name=\"findText\" type=\"text\" placeholder=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Find",{"name":"I18n","hash":{},"data":data}))
    + "\" class=\"rte-input\" data-wysihtml5-command=\"changeFindText\" data-wysihtml5-skip>\n    <input name=\"replaceText\" type=\"text\" placeholder=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Replace",{"name":"I18n","hash":{},"data":data}))
    + "\" class=\"rte-input\" data-wysihtml5-command=\"changeReplaceText\" data-wysihtml5-skip>\n    <div class=\"rte-block-group\">\n        <label>\n            <input name=\"matchCase\" type=\"checkbox\" class=\"rte_matchCase\" data-wysihtml5-command=\"changeMatchCase\" data-wysihtml5-skip>\n            "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Match case",{"name":"I18n","hash":{},"data":data}))
    + "\n        </label>\n        <label>\n            <input name=\"wholeWord\" type=\"checkbox\" class=\"rte_wholeWord\" data-wysihtml5-command=\"changeWholeWord\" data-wysihtml5-skip>\n            "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Whole word",{"name":"I18n","hash":{},"data":data}))
    + "\n        </label>\n        <label>\n            <input name=\"regExp\" onchange=\"this.form.wholeWord.disabled = this.checked\" type=\"checkbox\" class=\"rte_regExp\" data-wysihtml5-command=\"changeRegExp\" data-wysihtml5-skip>\n            "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Reg Ex",{"name":"I18n","hash":{},"data":data}))
    + "\n        </label>\n    </div>\n    <div class=\"rte-block-group\">\n    <button data-wysihtml5-command=\"find\" class=\"rte-button\" tabindex=\"-1\" type=\"button\">"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Find",{"name":"I18n","hash":{},"data":data}))
    + "</button>\n    <button tabindex=\"-1\" data-wysihtml5-command=\"replace\" class=\"rte-button\" type=\"button\">"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Replace",{"name":"I18n","hash":{},"data":data}))
    + "</button>\n    <button data-wysihtml5-command=\"replaceAll\" class=\"rte-button\" tabindex=\"-1\" type=\"button\">"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Replace all",{"name":"I18n","hash":{},"data":data}))
    + "</button>\n    </div>\n    <div class=\"rte_findNReplace_alert alert alert-info alert-dismissable\">\n        <button type=\"button\" class=\"close\" data-dismiss=\"alert\" aria-hidden=\"true\">\n            &times;\n        </button>\n        <strong>"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Info",{"name":"I18n","hash":{},"data":data}))
    + "</strong>\n        <span class=\"rte_findNReplace_message\"></span>\n    </div>\n</form>\n";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['findAndReplace'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['findAndReplace'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/group.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1, helper;

  return "<div class=\"rte-group "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" role=\"group\">\n"
    + ((stack1 = ((helper = (helper = helpers.content || (depth0 != null ? depth0.content : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"content","hash":{},"data":data}) : helper))) != null ? stack1 : "")
    + "\n</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['group'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['group'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/link.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    return "<form class=\"rte_insertLink_dialog\" role=\"form\">\n    <input type=\"text\" placeholder=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"URL",{"name":"I18n","hash":{},"data":data}))
    + "\" class=\"rte-input\" name=\"url\">\n    <input type=\"text\" placeholder=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Alt Text",{"name":"I18n","hash":{},"data":data}))
    + "\" value=\"\" name=\"alt\" class=\"rte-input\">\n    <span>\n        <input type=\"checkbox\" name=\"target\" value=\"false\">\n        "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Open in new page",{"name":"I18n","hash":{},"data":data}))
    + "\n    </span>\n    <button name=\"submit\" tabindex=\"-1\" class=\"rte-button rte-button-square\" type=\"button\" data-wysihtml5-command=\"createLink\" rte-close>\n        <span class=\"icon-ok\"></span>\n    </button>\n    <button tabindex=\"-1\" class=\"rte-button rte-button-square\" type=\"button\" rte-close>\n        <span class=\"icon-cancel\"></span>\n    </button>\n</form>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['link'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['link'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/numberInput.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var helper;

  return "<div class=\"rte-numberInput "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\">\n    <span>"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.label : depth0),{"name":"I18n","hash":{},"data":data}))
    + "</span>\n    <input class=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" value=\"0\" name=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" type=\"number\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-stateCallbackFn=\"Form.rte.CommandStateCallbacks.setNumberInputValue\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" unselectable=\"off\" data-wysihtml5-skip min=\"0\" step=\"any\">\n</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['numberInput'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['numberInput'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/popover.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1, helper;

  return "<div class=\"rte-popover\">\n    <button class=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + " rte-button rte-button-quiet "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" type=\"button\" data-placement=\""
    + container.escapeExpression(((helper = (helper = helpers.placement || (depth0 != null ? depth0.placement : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"placement","hash":{},"data":data}) : helper)))
    + "\" name=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-statecallbackfn=\""
    + container.escapeExpression(((helper = (helper = helpers.callback || (depth0 != null ? depth0.callback : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"callback","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\" href=\"javascript:;\" unselectable=\"on\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\">\n        <span class=\"icon-"
    + container.escapeExpression(((helper = (helper = helpers.icon || (depth0 != null ? depth0.icon : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"icon","hash":{},"data":data}) : helper)))
    + "\" aria-hidden=\"true\"></span>\n        "
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.text : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\n    </button>\n    <div class=\"popover\">"
    + ((stack1 = ((helper = (helper = helpers.content || (depth0 != null ? depth0.content : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"content","hash":{},"data":data}) : helper))) != null ? stack1 : "")
    + "</div>\n</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['popover'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['popover'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/rtetoolbar.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1;

  return "<div class=\"rte_toolBar\" role=\"toolbar\">"
    + ((stack1 = container.lambda(depth0, depth0)) != null ? stack1 : "")
    + "</div>";
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['rtetoolbar'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['rtetoolbar'] = template;


// Source: /apps/jnkn/workspace/greenShoots-RTE-Repo_release_660/main/target/checkout/content/src/main/templates/select.handlebars

  var template = Handlebars.template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
    var stack1, helper;

  return "<div class=\"rte-select\" title=\""
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.title : depth0),{"name":"I18n","hash":{},"data":data}))
    + "\">\n    <select class=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + " "
    + container.escapeExpression(((helper = (helper = helpers["class"] || (depth0 != null ? depth0["class"] : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"class","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-skip=\"\" data-wysihtml5-command=\""
    + container.escapeExpression(((helper = (helper = helpers.command || (depth0 != null ? depth0.command : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"command","hash":{},"data":data}) : helper)))
    + "\" data-wysihtml5-command-stateCallbackFn=\"Form.rte.CommandStateCallbacks.setSelectState\" data-wysihtml5-command-element=\""
    + container.escapeExpression(((helper = (helper = helpers.element || (depth0 != null ? depth0.element : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"element","hash":{},"data":data}) : helper)))
    + "\">\n        <option value=\"\" style=\"display:none\">"
    + container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},"Select",{"name":"I18n","hash":{},"data":data}))
    + "</option>\n"
    + ((stack1 = helpers.each.call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.options : depth0),{"name":"each","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "")
    + "    </select>\n    <i class=\"rte-toggleSelect icon-down-open\"></i>\n</div>\n";
},"1":function(container,depth0,helpers,partials,data) {
    var stack1;

  return "               <option value=\""
    + ((stack1 = helpers["if"].call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.value : depth0),{"name":"if","hash":{},"fn":container.program(2, data, 0),"inverse":container.program(4, data, 0),"data":data})) != null ? stack1 : "")
    + "\">"
    + ((stack1 = helpers["if"].call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.label : depth0),{"name":"if","hash":{},"fn":container.program(6, data, 0),"inverse":container.program(8, data, 0),"data":data})) != null ? stack1 : "")
    + "</option>\n";
},"2":function(container,depth0,helpers,partials,data) {
    var helper;

  return container.escapeExpression(((helper = (helper = helpers.value || (depth0 != null ? depth0.value : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : {},{"name":"value","hash":{},"data":data}) : helper)));
},"4":function(container,depth0,helpers,partials,data) {
    return container.escapeExpression(container.lambda(depth0, depth0));
},"6":function(container,depth0,helpers,partials,data) {
    return container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.label : depth0),{"name":"I18n","hash":{},"data":data}));
},"8":function(container,depth0,helpers,partials,data) {
    return container.escapeExpression((helpers.I18n || (depth0 && depth0.I18n) || helpers.helperMissing).call(depth0 != null ? depth0 : {},depth0,{"name":"I18n","hash":{},"data":data}));
},"useData":true});
  var templates = Handlebars.templates = Handlebars.templates || {};
  templates['select'] = template;
  var partials = Handlebars.partials = Handlebars.partials || {};
  partials['select'] = template;



})();
/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/29/2016.
 */

(function (ns) {

    /* Out of the box provided Commands*/
    var Commands = ns.Commands = {};

    Commands.UNDO = "undo";
    Commands.REDO = "redo";

    Commands.BOLD = "bold";
    Commands.ITALIC = "italic";
    Commands.UNDERLINE = "underline";
    Commands.SUPERSCRIPT = "superscript";
    Commands.SUBSCRIPT = "subscript";
    Commands.FORE_COLOR = "foreColor";
    Commands.HILITE_COLOR = "hiliteColor";

    Commands.FONT_FAMILY = "fontFamily";
    Commands.FONT_SIZE = "fontSize";
    Commands.LINE_HEIGHT = "lineHeight";
    Commands.LETTER_SPACING = "letterSpacing";
    Commands.HEADER = "header";

    Commands.JUSTIFY_LEFT = "justifyLeft";
    Commands.JUSTIFY_CENTER = "justifyCenter";
    Commands.JUSTIFY_FULL = "justifyFull";
    Commands.JUSTIFY_RIGHT = "justifyRight";

    Commands.MARGIN_LEFT = "marginLeft";
    Commands.MARGIN_RIGHT = "marginRight";
    Commands.MARGIN_TOP = "marginTop";
    Commands.MARGIN_BOTTOM = "marginBottom";

    Commands.INSERT_UNORDERED_LIST = "insertUnorderedList";
    Commands.INSERT_ORDERED_LIST = "insertOrderedList";
    Commands.INSERT_UPPERCASE_ALPHABET_LIST = "insertUppercaseAlphabetList";
    Commands.INSERT_LOWERCASE_ALPHABET_LIST = "insertLowercaseAlphabetList";
    Commands.INSERT_UPPERCASE_ROMAN_LIST = "insertUppercaseRomanList";
    Commands.INSERT_LOWERCASE_ROMAN_LIST = "insertLowercaseRomanList";

    Commands.INDENT = "indent";
    Commands.OUTDENT = "outdent";

    Commands.MODE = "mode";
    Commands.FIND_AND_REPLACE = "findAndReplace";
    Commands.LINK = "link";
    Commands.INSERT_TEXT = "insertText";

    /* Toolbar Modes*/
    var ToolbarMode = ns.ToolbarMode = {};
    ToolbarMode.BASIC = "basic";
    ToolbarMode.FULL = "full";

    var Keyboard = ns.Keyboard = {};

    Keyboard.KEYCODE_B = 66;
    Keyboard.KEYCODE_I = 73;
    Keyboard.KEYCODE_U = 85;
    Keyboard.KEYCODE_S = 83;
    Keyboard.KEYCODE_E = 69;
    Keyboard.KEYCODE_L = 76;
    Keyboard.KEYCODE_R = 82;
    Keyboard.KEYCODE_J = 74;
    Keyboard.KEYCODE_GREATER_THAN = 190;
    Keyboard.KEYCODE_LESS_THAN = 188;

})(Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (ns) {
    "use strict";

    /* Default Editor configurations*/
    ns.DefaultConfig = {
        fontFamily : {
            defaultValue : "Times New Roman",
            options : ["Times New Roman", "Arial", "Courier", "Courier New", "Geneva", "Georgia", "Helvetica", "Tahoma", "Times", "Verdana"]
        },
        fontSize : {
            defaultValue : 12,
            options : [8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 26, 28, 36, 48, 72]
        },
        lineHeight : {
            options : [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
        },
        letterSpacing : {
            defaultValue : "0",
            options : ["0", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
        },
        header : {
            defaultValue : "p",
            options : [
                {
                    value : "p",
                    label : "None"
                },
                {
                    value : "h1",
                    label : "Header 1"
                },
                {
                    value : "h2",
                    label : "Header 2"
                },
                {
                    value : "h3",
                    label : "Header 3"
                },
                {
                    value : "h4",
                    label : "Header 4"
                },
                {
                    value : "h5",
                    label : "Header 5"
                },
                {
                    value : "h6",
                    label : "Header 6"
                }
            ]
        },
        color : {
            white : 'fff',
            red : 'f00',
            orange : 'f60',
            yellow : 'ff0',
            green : '008000',
            blue : '00f',
            purple : '800080',
            black : '000'
        }
        //TODO : add configuration for Custom classes
    };

    /* Out of the box toolbar configuration provided */
    ns.ToolbarConfig = {
        defaultMode : 'basic',
        toolbars : {
            basic : {
                layout : [
                    {
                        name : "Header",
                        items : [ns.Commands.HEADER]
                    },
                    {
                        name : "Paragraph",
                        items : [ns.Commands.BOLD, ns.Commands.ITALIC, ns.Commands.UNDERLINE]
                    },
                    {
                        command : 'lists',
                        title : "List Type",
                        icon : 'list',
                        type : 'popover',
                        placement : 'bottom',
                        items : [ns.Commands.INSERT_UNORDERED_LIST,
                            ns.Commands.INSERT_ORDERED_LIST,
                            ns.Commands.INSERT_LOWERCASE_ALPHABET_LIST]
                    },
                    {
                        title : 'Expand',
                        command : ns.Commands.MODE,
                        value : ns.ToolbarMode.FULL,
                        icon : 'resize-full'
                    }
                ],
                floating : true
            },
            full : {
                layout : [
                    {
                        items : [ns.Commands.UNDO, ns.Commands.REDO, ns.Commands.LINK, ns.Commands.FIND_AND_REPLACE]
                    },
                    {
                        name : "Paragraph",
                        items : [
                            ns.Commands.HEADER,
                            ns.Commands.FONT_FAMILY,ns.Commands.FONT_SIZE,
                            ns.Commands.BOLD, ns.Commands.ITALIC, ns.Commands.UNDERLINE,
                            ns.Commands.SUPERSCRIPT, ns.Commands.SUBSCRIPT,
                            ns.Commands.LETTER_SPACING,
                            ns.Commands.LINE_HEIGHT,
                            ns.Commands.FORE_COLOR,
                            ns.Commands.HILITE_COLOR
                        ]
                    },
                    {
                        name : "Alignment",
                        items : [
                            ns.Commands.JUSTIFY_LEFT, ns.Commands.JUSTIFY_CENTER, ns.Commands.JUSTIFY_FULL, ns.Commands.JUSTIFY_RIGHT,
                            ns.Commands.MARGIN_LEFT, ns.Commands.MARGIN_RIGHT, ns.Commands.MARGIN_TOP, ns.Commands.MARGIN_BOTTOM
                        ]
                    },
                    {
                        name : "Listing",
                        items : [ns.Commands.INSERT_UNORDERED_LIST,
                                ns.Commands.INSERT_ORDERED_LIST,
                                ns.Commands.INSERT_UPPERCASE_ALPHABET_LIST,
                                ns.Commands.INSERT_LOWERCASE_ALPHABET_LIST,
                                ns.Commands.INSERT_UPPERCASE_ROMAN_LIST,
                                ns.Commands.INSERT_LOWERCASE_ROMAN_LIST,
                                ns.Commands.INDENT, ns.Commands.OUTDENT
                        ]
                    },
                    {
                        title : 'Collapse',
                        command : ns.Commands.MODE,
                        value : ns.ToolbarMode.BASIC,
                        icon : 'resize-small',
                        selected : true
                    }
                ]
            }
        }
    };
})(Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/29/2016.
 */

(function (ns) {

    var FindAndReplace = ns.FindAndReplace = function (textEditor) {
        this.textEditor = textEditor;
        this._message = "";
        this._wholeWordEnabled = true;
        this.isDirty = true;
        this.isValid = true;
        Object.defineProperties(this, {"source" : {"get" : function () {
            return this.textEditor && this.textEditor.editor && this.textEditor.editor.composer && this.textEditor.editor.composer.container ? this.textEditor.editor.composer.container.textContent || this.textEditor.editor.composer.container.outerText : "";
        }}});
        Object.defineProperties(this, {"message" : {"get" : function () {
            return this._message;
        }, "set" : function (value) {
            this._message = value;
        }}});
        Object.defineProperties(this, {"wholeWordEnabled" : {"get" : function () {
            return this._wholeWordEnabled;
        }, "set" : function (value) {
            this._wholeWordEnabled = value;
        }}});
    };

    FindAndReplace.prototype.setSelectionAndHighlight = function (container, relativeStart, relativeEnd) {
        if (container == null) {
            container = this.textEditor.container;
            if (!container) {
                return;
            }
        }
        var charIndex = 0, range = document.createRange();
        range.setStart(document, 0);
        range.collapse(true);
        var nodeStack = [container], node, foundStart = false, stop = false;
        var newLineCount = 0;
        while (!stop && (node = nodeStack.pop())) {
            if (node && node.nodeType == 3) {
                var nextCharIndex = charIndex + node.nodeValue.length;
                if (this.relativeStart >= charIndex && this.relativeStart <= nextCharIndex) {
                    range.setStart(node, this.relativeStart - charIndex);
                    foundStart = true;
                }
                if (foundStart && this.relativeEnd >= charIndex && this.relativeEnd <= nextCharIndex) {
                    range.setEnd(node, this.relativeEnd - charIndex);
                    stop = true;
                }
                charIndex = nextCharIndex;
            } else {
                var i = node.childNodes.length;
                while (i--) {
                    nodeStack.push(node.childNodes[i]);
                }
            }
        }

        var sel = document.getSelection();
        sel.removeAllRanges();
        sel.addRange(range);
    };

    FindAndReplace.prototype.onRegExpSelectionChange = function () {
        this.onSelectionChange();
        this.setWholeWordEnabled();
    };

    FindAndReplace.prototype.onFindValueChange = function (findVal) {
        if (findVal != this.findText) {
            this.findText = findVal;
        }
        this.onSelectionChange();
        this.setWholeWordEnabled();
    };

    FindAndReplace.prototype.onReplaceValueChange = function () {
        this.onSelectionChange();
    };

    FindAndReplace.prototype.setWholeWordEnabled = function () {
        if (this.findText) {
            var result = ns.util.StringHelper.restrict(this.findText, "^`~!@#%&*()=+[]{}/\|'\";:/?.><,");
            if (this.findText != result) {
                this.wholeWordEnabled = false;
            } else if (this.isRegEx) {
                this.wholeWordEnabled = !this.isRegEx;
            } else {
                this.wholeWordEnabled = true;
            }
            if (!this.wholeWordEnabled) {
                this.isWholeWord = false;
            }
        }
    };

    FindAndReplace.prototype.onSelectionChange = function (isCaseSensitiveVal, isWholeWordVal, isRegExVal) {
        this.isDirty = true;
        this.relativeStart = -1;
        this.relativeEnd = -1;
        this.message = "";

        if (isWholeWordVal !== undefined && isWholeWordVal != null) {
            this.isWholeWord = isWholeWordVal;
        }
        if (isRegExVal !== undefined && isRegExVal != null && this.isRegEx !== isRegExVal) {
            this.isRegEx = isRegExVal;
            this.setWholeWordEnabled();
        }
        if (isCaseSensitiveVal !== undefined && isCaseSensitiveVal != null) {
            this.isCaseSensitive = isCaseSensitiveVal;
        }
    };

    FindAndReplace.prototype.clear = function () {
        this.isValid = this.findText ? true : false;
        this.isDirty = true;
        this.message = "";
        this.relativeStart = -1;
        this.relativeEnd = -1;
    };

    FindAndReplace.prototype.executeFind = function (findVal) {
        this.findText = findVal;
        if (this.findText) {
            this.findPosition(this.findText);
            this.setSelectionAndHighlight(null, this.relativeStart, this.relativeEnd, true);
        }
    };

    FindAndReplace.prototype.adjustSearchPositionAfterReplace = function (newVal) {
        if (this.relativeEnd != -1 || this.relativeStart != -1) {
            this.relativeEnd = this.relativeStart + newVal.length;
        }
    };

    FindAndReplace.prototype.executeReplace = function (findVal, replaceVal) {
        this.findText = findVal;
        if (findVal) {
            this.replace(findVal, replaceVal);
            this.executeFind(findVal);
        }
    };

    FindAndReplace.prototype.executeReplaceAll = function (findVal, replaceVal) {
        this.findText = findVal;
        if (findVal) {
            this.replaceAll(findVal, replaceVal);
        }
    };

    FindAndReplace.prototype.createRegExp = function (searchText) {
        if (this.isDirty || !this.regExp) {
            if (this.isRegEx && this.isCaseSensitive) {
                this.regExp = new RegExp(searchText, "g");
            } else if (this.isWholeWord && this.isCaseSensitive) {
                this.regExp = new RegExp("\\b" + searchText + "\\b", "g");
            } else if (this.isWholeWord) {
                this.regExp = new RegExp("\\b" + searchText + "\\b", "ig");
            } else {
                this.regExp = new RegExp(searchText, "ig");
            }
            this.isDirty = false;
        }
    };
    FindAndReplace.prototype.findPosition = function (search) {
        if (this.isRegEx || this.isWholeWord) {
            this.findPositionWithRegExp(search);
        } else {
            this.findPositionWithIndexOf(search);
        }
    };
    FindAndReplace.prototype.findPositionWithRegExp = function (search) {
        if (this.isDirty || !this.regExp) {
            this.createRegExp(search);
        }
        var result = this.regExp.exec(this.source);
        if (result && result.hasOwnProperty("index")) {
            this.setPosition(result.index, result.index + result[0].length);
        } else {
            this.setPosition(-1, -1);
        }
    };

    FindAndReplace.prototype.findPositionWithIndexOf = function (search) {
        var modifiedSource = this.source;
        var startFrom = 0;
        if (this.isDirty) {
            startFrom = 0;
            this.isDirty = false;
        } else {
            startFrom = this.relativeEnd;
        }
        if (!this.isCaseSensitive) {
            modifiedSource = this.source.toLocaleLowerCase();
            search = search.toLocaleLowerCase();
        }
        var start = modifiedSource.indexOf(search, startFrom);
        var end = start != -1 ? start + search.length : -1;
        this.setPosition(start, end);
    };
    FindAndReplace.prototype.setPosition = function (start, end) {
        if ((start == -1 || end == -1) && this.relativeEnd > 0) {
            this.message = ns.I18n.get("Reached end of module.");
        } else if (start == -1 || end == -1) {
            this.message = ns.I18n.get("Match Not Found");
        } else {
            this.message = "";
        }
        this.relativeStart = start;
        this.relativeEnd = end;
    };
    FindAndReplace.prototype.replace = function (search, replaceWith) {
        if (this.relativeStart == -1 || this.relativeEnd == -1) {
            this.findPosition(search);
        }
        this.replaceValue(replaceWith);
    };

    FindAndReplace.prototype.replaceAll = function (search, replaceWith) {
        var replaceCount = 0;
        this.relativeStart = this.relativeEnd = -1;
        this.findPosition(search);
        while (this.relativeStart != -1) {
            replaceCount++;
            this.replaceValue(replaceWith);
            this.findPosition(search);
        }
        this.message = replaceCount == 0 ? ns.I18n.get("Match Not Found") : ns.I18n.get("{0} matches replaced", [replaceCount]);
    };
    FindAndReplace.prototype.replaceValue = function (replaceWith) {
        if (this.textEditor) {
            this.setSelectionAndHighlight(null, this.relativeStart, this.relativeEnd, false);
            this.textEditor.executeCommand("insertText", replaceWith);
            this.adjustSearchPositionAfterReplace(replaceWith);
        }
    };

})(Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/27/2016.
 */

(function ($, ns) {
    "use strict";

    Handlebars.registerHelper('I18n', function (object) {
        return new Handlebars.SafeString(ns.I18n.get(object));
    });

    var commands = {
        undo : {
            title : 'Undo',
            text : 'Undo',
            icon : 'ccw'
        },
        redo : {
            title : 'Redo',
            text : 'Redo',
            icon : 'cw'
        },
        bold : {
            title : 'Bold',
            icon : 'bold'
        },
        italic : {
            title : 'Italic',
            icon : 'italic'
        },
        underline : {
            title : 'Underline',
            icon : 'underline',
            'class' : 'rte-custom-icon'
        },
        superscript : {
            title : 'Super-script',
            icon : 'superscript'
        },
        subscript : {
            title : 'Sub-script',
            icon : 'subscript'
        },
        foreColor : {
            title : 'Text Color',
            type : 'colorInput',
            icon : 'text-color'
        },
        hiliteColor : {
            title : 'Highlight Color',
            type : 'colorInput'
        },
        fontFamily : {
            type : 'select',
            title : 'Font Family'
        },
        fontSize : {
            type : 'select',
            title : 'Font Size'
        },
        lineHeight : {
            type : 'select',
            command : 'changeLineHeight',
            title : 'Line Height'
        },
        letterSpacing : {
            type : 'select',
            title : 'Letter Spacing'
        },
        header : {
            type : 'select',
            title : 'Paragraph Format'
        },
        justifyLeft : {
            title : 'Justify Left',
            icon : 'align-left'
        },
        justifyCenter : {
            title : 'Justify Center',
            icon : 'align-center'
        },
        justifyFull : {
            title : 'Justify Full',
            icon : 'align-justify'
        },
        justifyRight : {
            title : 'Justify Right',
            icon : 'align-right'
        },
        marginLeft : {
            type : 'numberInput',
            title : 'Margin Left'
        },
        marginRight : {
            type : 'numberInput',
            title : 'Margin Right'
        },
        marginTop : {
            type : 'numberInput',
            title : 'Margin Top'
        },
        marginBottom : {
            type : 'numberInput',
            title : 'Margin Bottom'
        },
        insertUnorderedList : {
            title : 'Bulleted List',
            icon : "list"
        },
        insertOrderedList : {
            command : "insertOrderedList",
            value : "Ordered",
            title : "Numbered List",
            icon : "textNumbered",
            'class' : "rte-custom-icon"
        },
        insertUppercaseAlphabetList : {
            command : "insertOrderedList",
            element : "rte_caps_alpha_list_command",
            value : "A",
            title : "Upper-case Alphabet List",
            icon : "textLetteredUppercase",
            'class' : "rte-custom-icon"
        },
        insertLowercaseAlphabetList : {
            command : "insertOrderedList",
            element : "rte_alpha_list_command",
            value : "a",
            title : "Lower-case Alphabet List",
            icon : "textLetteredLowercase",
            'class' : "rte-custom-icon"
        },
        insertUppercaseRomanList : {
            command : "insertOrderedList",
            element : "rte_caps_roman_list_command",
            value : "I",
            title : "Upper-case Roman List",
            icon : "textRomanUppercase",
            'class' : "rte-custom-icon"
        },
        insertLowercaseRomanList : {
            command : "insertOrderedList",
            element : "rte_roman_list_command",
            value : "i",
            title : "Lower-case Roman List",
            icon : "textRomanLowercase",
            'class' : "rte-custom-icon"
        },
        indent : {
            title : 'Indent',
            icon : "indent-left"
        },
        outdent : {
            title : 'Outdent',
            icon : "indent-right"
        },
        findAndReplace : {
            text : "Find & Replace",
            icon : 'search',
            type : 'popover',
            content : Handlebars.templates.findAndReplace(),
            callback : "Form.rte.CommandStateCallbacks.setFindAndReplaceMessage",
            placement : 'bottom'
        },
        link : {
            title : "Insert Link",
            icon : 'link',
            type : 'popover',
            content : Handlebars.templates.link(),
            placement : 'bottom'
        }
    };

    ns.Toolbar = function (options, config) {
        this.toolbars = (options && options.toolbars) || ns.ToolbarConfig.toolbars;
        this.modes = {};
        this.mode = (options && options.defaultMode) || ns.ToolbarConfig.defaultMode;
        this.config = config;
    };

    /**
     * Renders the toolbar specific to current mode
     * @returns {*}
     */
    ns.Toolbar.prototype.render = function () {
        var mode = this.mode;
        var config = this.config;
        if (!this.modes.hasOwnProperty(mode)) {
            var toolbarHTML = "";
            var modeConfig = this.toolbars[mode];
            try {
                var layout = modeConfig.layout;
                if (layout instanceof Array) {
                    layout.forEach(function (item) {
                        toolbarHTML += renderCommands(item, config);
                    });
                }
                this.modes[mode] =  $(Handlebars.templates.rtetoolbar(toolbarHTML));
            } catch (e) {
                console.error("Error in constructing Toolbar : " + e);
            }
        }
        return this.modes[mode];
    };

    /**
     * Set current mode of the Toolbar
     * @param mode
     */
    ns.Toolbar.prototype.setMode = function (mode) {
        this.mode = mode;
        return this.render();
    };

    /**
     * Returns current mode of the Toolbar
     * @returns Current mode
     */
    ns.Toolbar.prototype.getMode = function () {
        return this.mode;
    };

    ns.Toolbar.prototype._toggleFloatingToolbar = function (rte, toolbar, e, show) {
        var editor = rte.$element.find(".wysihtml5-editor")[0],
            editorFocused = show || editor.contains(e.target) || editor == e.target,
            toolbarFocused = e && toolbar.has(e.target);
        if (editorFocused) {
            toolbar.show();
            var offset = $(editor).offset();
            toolbar.offset({
                top : offset.top - toolbar.height() - 4,
                left : offset.left
            });
        } else if (!toolbarFocused || toolbarFocused.length == 0) {
            toolbar.hide();
        }
    };

    ns.Toolbar.prototype.initializeToolbarEvents = function (rte) {
        var mode = this.mode;
        if (this.modes.hasOwnProperty(mode)) {
            var toolbar = this.modes[mode];
            if (this.toolbars && this.toolbars[mode] && this.toolbars[mode].floating && !this.toggleToolbar) {
                /* Add focus handler to editor if the toolbar is of floating nature */
                this.toggleToolbar = $.proxy(this._toggleFloatingToolbar, this, rte, toolbar);
                $(document).on("mouseup", this.toggleToolbar);
            }
            var self = this;
            /* Listen for mode change on toolbar */
            if (toolbar.hasClass("initialized")) {
                return;
            }
            toolbar.find("[data-wysihtml5-command='mode']").on("click", function () {
                var mode = this.getAttribute("data-wysihtml5-command-value");
                $(self).trigger("modeChanged", mode);
            });
            var colors = rte.editorConfig ? rte.editorConfig.color : {};
            toolbar.find(".rte-colorInput-control:not(.pick-a-color)").pickAColor({
                touchOnlyMode : false, // for touch-only devices [tablet, smartphone, etc.]
                showSpectrum : true,
                showSavedColors : false,
                saveColorsPerElement : false,
                fadeMenuToggle : true,
                showAdvanced : true,
                showBasicColors : true,
                showHexInput : false,
                basicColors : colors
            }).on('change', function (e) {
                rte.executeCommand(e.target.getAttribute("data-wysihtml5-command"), "#" + e.target.value);
            });

            for (var color in colors) {
                if (colors.hasOwnProperty(color)) {
                    var selector = toolbar.find(".pick-a-color-markup .spectrum-" + color);
                    ns.util.RTEUtils.addSpectrumGradient(selector, colors[color]);
                }
            }
            toolbar.on("click", ".rte-popover > button", function () {
                var popover = $(this).siblings(".popover");
                var offset = $(this).offset();
                offset.top += this.clientHeight;
                popover.toggle();
                popover.offset(offset);
            });
            toolbar.on("click", ".rte-popover > .rte_link_command", function () {
                var popover = $(this).siblings(".popover");
                if (popover) {
                    var text = rte.composer && rte.composer.selection ? rte.composer.selection.getText() : "";
                    popover.find("input[name='alt']").val(text);
                }
            });

            toolbar.on("click", ".rte-popover .popover [rte-close]", function () {
                var popover = $(this).closest(".popover");
                popover.hide();
            });

            this._toggleFloatingToolbar(rte, toolbar, null, true);
            toolbar.addClass("initialized");
        }
    };

    var renderCommands = function (commandObj, config) {
        var html = "";
        var itemConfig;
        if (typeof commandObj == "string") {
            /* Fetch configuration from OOTB command if present */
            if (commands && commands.hasOwnProperty(commandObj)) {
                itemConfig = commands[commandObj];
                itemConfig.command = itemConfig.command || commandObj;
            }
        } else if (typeof commandObj == "object") {
            /* Fetch configuration from OOTB command if present */
            itemConfig = $.extend(commands[commandObj.command], commandObj);
        }
        if (itemConfig) {
            if (config && config.hasOwnProperty(commandObj)) {
                itemConfig = $.extend(itemConfig, config[commandObj]);
            }
            if (itemConfig.items) {
                itemConfig.type = itemConfig.type ||  "group";
                itemConfig.content = "";
                itemConfig.items.forEach(function (i) {
                    itemConfig.content += renderCommands(i, config);
                });
            }
            /* templateType defaults to group if it contains any items else defaults to button*/
            itemConfig.type = itemConfig.type || "button";
            itemConfig.element = itemConfig.element || "rte_" + itemConfig.command + "_command";
            if (Handlebars.templates.hasOwnProperty(itemConfig.type)) {
                html += Handlebars.templates[itemConfig.type](itemConfig);
            } else {
                console.error("Unable to retrieve template for " + itemConfig.type);
            }
        }
        return html;
    };
})($, Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
/**
 * Created by ramnani on 7/27/2016.
 */

(function (document, ns) {

    var callbackFunctions = ns.CommandStateCallbacks = {};

    /**
     * Callback to set Button state corresponding to command
     * @param domElem element to set state on
     * @param state whether command executed or not
     */
    callbackFunctions.setButtonState = function (domElement, state) {
        state = !(state == undefined || state == false);
        if (domElement) {
            if (state) {
                domElement.classList.add("active");
            } else {
                domElement.classList.remove("active");
            }
        }
    };

    /**
     * Callback to set Dropdown state corresponding to command
     * @param value value of the dropdown to set
     * @param domElement element to set state on
     */
    callbackFunctions.setSelectState = function (domElement, value) {
        if (domElement) {
            var options = domElement.options,
                isOptionPresent = false;
            if (options) {
                for (var i = 0; i < options.length; i++) {
                    if (options[i].value == value) {
                        isOptionPresent = true;
                        break;
                    }
                }
            }
            if (!isOptionPresent) {
                value = "";
            }
            domElement.value = value;
        }
    };

    /**
     * Callback to set Number Input state corresponding to command
     * @param value value to set
     * @param numberInput element to set value to
     */
    callbackFunctions.setNumberInputValue = function (numberInput, value) {
        if (numberInput) {
            numberInput.value = value;
        }
    };

    /**
     * Callback to set Find & Replace message
     * @param message message to set
     * @param findReplaceButton
     */
    callbackFunctions.setFindAndReplaceMessage = function (findReplaceButton, message) {
        var popover = $(findReplaceButton).siblings(".popover")[0];
        if (popover) {
            var messageEl = popover.querySelector(".rte_findNReplace_message");
            var alert = popover.querySelector(".rte_findNReplace_alert");
            if (messageEl && alert) {
                messageEl.innerHTML = message;
                if (message && message.trim() != "") {
                    $(alert).show();
                } else {
                    $(alert).hide();
                }
            }
        }
    };

    callbackFunctions.setColorInputValue = function (domElement, state, domElementName, cmd) {
        if (domElement) {
            var color = "rgb(0, 0, 0)";
            if (state && state.style) {
                if (cmd == Form.rte.Commands.FORE_COLOR) {
                    color = state.style.color;
                } else if (cmd == Form.rte.Commands.HILITE_COLOR) {
                    color = state.style.backgroundColor;
                }
            }
            $(domElement).closest(".pick-a-color-markup").find(".current-color").css("background-color", color);
        }
    };
})(document, Form.rte);


/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (document, ns) {
    "use strict";

    var ShortcutKeysCtrl = ns.ShortcutKeysCtrl = {};

    var getFontSize = function (next, composer, fontSizeList) {
        var fontSize = composer.commands.callbackState("fontSize");
        if (typeof fontSize === "string") {
            fontSize = parseFloat(fontSize);
        }
        if (fontSizeList && fontSizeList.length > 0) {
            var fontIndex = -1,
                i = 0,
                value = parseFloat(fontSizeList[i]);
            while (i < fontSizeList.length && value < fontSize) {
                value = parseFloat(fontSizeList[++i]);
            }
            if (value == fontSize) {
                fontIndex = next ? i + 1 : i - 1;
            } else {
                fontIndex = next ? i : i - 1;
            }
            if (fontIndex > -1 && fontIndex < fontSizeList.length) {
                return fontSizeList[fontIndex];
            }
        }
        return null;
    };

    ShortcutKeysCtrl.onkeydown = function (event, composer, config) {
        var isCtrl = event.ctrlKey,
            isAlt = event.altKey,
            isShift = event.shiftKey,
            which = event.which;
        if (isCtrl && isShift) {
            var fontSize = null,
                fontSizeOptions = config.fontSize ? config.fontSize.options : [];
            if (which == ns.Keyboard.KEYCODE_GREATER_THAN) {// Ctrl + Shift + > to Increase font size
                fontSize = getFontSize(true, composer, fontSizeOptions);
            } else if (which == ns.Keyboard.KEYCODE_LESS_THAN) {// Ctrl + Shift + < to Decrease font size
                fontSize = getFontSize(false, composer, fontSizeOptions);
            }
            if (fontSize) {
                event.preventDefault();
                composer.commands.exec("fontSize", fontSize, false);
            }
        } if (isCtrl) {
            var command = "";
            if (isAlt) {
                if (which == ns.Keyboard.KEYCODE_B) {// Ctrl + Alt + B for Bold
                    command = "bold";
                } else if (which == ns.Keyboard.KEYCODE_I) {// Ctrl + Alt + I for Italic
                    command = "italic";
                } else if (which == ns.Keyboard.KEYCODE_U) {// Ctrl + Alt + U for Underline
                    command = "underline";
                }
            } else {
                if (which == ns.Keyboard.KEYCODE_E) {// Ctrl + E for Center-Aligned Text
                    command = "justifyCenter";
                } else if (which == ns.Keyboard.KEYCODE_L) {//Ctrl + L for Left-Aligned Text
                    command = "justifyLeft";
                } else if (which == ns.Keyboard.KEYCODE_R) {//Ctrl + R for Right-Aligned Text
                    command = "justifyRight";
                } else if (which == ns.Keyboard.KEYCODE_J) {//Ctrl + J for Fully-Justified Text
                    command = "justifyFull";
                }
            }
            if (command != "") {
                event.preventDefault();
                composer.commands.exec(command, undefined, true);
            }
        }
    };

})(document, Form.rte);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2016. Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function (document, $, ns) {
    "use strict";

    /**
     * Creates an instance of Rich Text Editor which takes object with following configurations :
     * Selector : selector or DOM element of Element for which RTE needs to be linked
     * Toolbar : selector of Toolbar or config to use custom Toolbar
     * data : HTML to be set while instantiating
     *
     * @type {RichTextEditor}
     */
    var RichTextEditor = ns.RichTextEditor = function (options) {

        var selector = typeof options.selector === "string" ? document.getElementById(options.selector) : options.selector;
        var toolbar = options.toolbar;
        ns.I18n.setLocale(options.locale);
        this.editorConfig = $.extend(ns.DefaultConfig, options.config);

        var insertAfter;
        var richTextEditor = $("<div class='forms-richTextEditor'></div>");
        if (!(toolbar instanceof HTMLElement || typeof toolbar == "string")) {
            /* Create out of the box toolbar is no toolbar DOM element or selector is provider*/
            this.toolbar = new ns.Toolbar(toolbar, this.editorConfig);
            this.$toolbar = this.toolbar.render();
            insertAfter = toolbar = this.$toolbar[0];
            richTextEditor.append(this.$toolbar);
            richTextEditor.addClass("rte-mode-" + this.toolbar.getMode());
        } else {
            insertAfter = $("<div></div>")[0];
            richTextEditor.append(insertAfter);
        }

        richTextEditor.insertAfter($(selector));
        this.$element = richTextEditor;

        var parserRules = wysihtml5SupportedParserRules;
        if (options.parserRules) {
            if (options.parserRules.tags) {
                parserRules.tags = $.extend(parserRules.tags, options.parserRules.tags);
            }
            if (options.parserRules.classes) {
                parserRules.classes = $.extend(parserRules.classes, options.parserRules.classes);
            }
            if (options.parserRules.styles) {
                parserRules.styles = parserRules.styles.concat(options.parserRules.styles);
            }
            if (options.parserRules.pseudoTags) {
                parserRules.pseudoTags = options.parserRules.pseudoTags;
            }
            if (options.parserRules.textNodes) {
                parserRules.textNodes = options.parserRules.textNodes.map(function (nodeName) {
                    return nodeName.toUpperCase();
                });
            }
        }

        if (window.hasOwnProperty("wysihtml5") && window.wysihtml5) {
            if (!this.editor) {
                this.editor = new wysihtml5.Editor(selector, {
                    toolbar : toolbar,
                    insertAfter : insertAfter,
                    useLineBreaks : false,
                    pasteAsPlainText : false,
                    stylesheets : options.cssPath,
                    defaultFontSize : this.editorConfig.fontSize.defaultValue,
                    parserRules : parserRules
                });
                if (this.editor.composer) {
                    var composer = this.editor.composer,
                        container = composer.container,
                        doc = composer.doc,
                        config = this.editorConfig;
                    if (container) {
                        for (var style in this.editorConfig) {
                            if (this.editorConfig.hasOwnProperty(style)) {
                                container.style[style] = this.editorConfig[style].defaultValue;
                            }
                        }
                    }
                    $(doc).on("keydown", function (e) {
                        ns.ShortcutKeysCtrl.onkeydown(e, composer, config);
                    });
                }
                if (options.data) {
                    this.setRichTextEditorContent(options.data);
                }
                var findAndReplace = this.findAndReplace = new ns.FindAndReplace(this);
                RichTextEditor.addCommand("changeLineHeight", {
                    exec : function (composer, commandName, value) {
                        wysihtml5.util.changeLineHeight(value, true, null, composer, true);
                    },
                    state : wysihtml5.commands.lineHeight.state,
                    callbackState : wysihtml5.commands.lineHeight.callbackState

                });
                RichTextEditor.addCommand("findAndReplace", {
                    state : function () {
                        return findAndReplace.message;
                    }
                });
                RichTextEditor.addCommand("find", {
                    focus : false,
                    exec : function (composer, commandName, values) {
                        if (values) {
                            findAndReplace.executeFind(values.findText);
                        }
                    }
                });
                RichTextEditor.addCommand("replace", {
                    focus : false,
                    exec : function (composer, commandName, values) {
                        if (values) {
                            findAndReplace.executeReplace(values.findText, values.replaceText);
                        }
                    }
                });
                RichTextEditor.addCommand("replaceAll", {
                    focus : false,
                    exec : function (composer, commandName, values) {
                        if (values) {
                            findAndReplace.executeReplaceAll(values.findText, values.replaceText);
                        }
                    }
                });
                RichTextEditor.addCommand("changeFindText", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onFindValueChange(value);
                    }
                });
                RichTextEditor.addCommand("changeReplaceText", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onReplaceValueChange(value);
                    }
                });
                RichTextEditor.addCommand("changeWholeWord", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onSelectionChange(undefined, value, undefined);
                    }
                });
                RichTextEditor.addCommand("changeMatchCase", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onSelectionChange(value);
                    }
                });
                RichTextEditor.addCommand("changeRegExp", {
                    focus : false,
                    exec : function (composer, commandName, value) {
                        findAndReplace.onSelectionChange(undefined, undefined, value);
                    }
                });
                if (this.toolbar) {
                    this.toolbar.initializeToolbarEvents(this);
                    $(this.toolbar).on("modeChanged", $.proxy(this.toggleToolbarMode, this));
                }
            }
        }
        Object.defineProperties(this, {"composer" : {"get" : function () {
            return (this.editor && this.editor.composer) ? this.editor.composer : null;
        }}});
        Object.defineProperties(this, {"container" : {"get" : function () {
            return (this.editor && this.editor.composer) ? this.editor.composer.container : null;
        }}});
        Object.defineProperties(this, {"doc" : {"get" : function () {
            return document;
        }}});
    };

    /**
     * Sets the html provided to the Rich Text Editor
     * @param htmlData Html to be inserted
     */
    RichTextEditor.prototype.setRichTextEditorContent = function (htmlData) {
        if (htmlData !== this.getRichTextEditorContent()) {
            htmlData = htmlData || "";
            var pattern = new RegExp('<br><\/br>', 'gi');
            htmlData = htmlData.replace(pattern, "<br>");
            if (htmlData.indexOf("<body") > -1) {
                htmlData = ns.util.HtmlUtils.extractBodyContent(htmlData);
            }
            this.editor.setValue(htmlData);
            if (this.editor.composer && this.editor.composer.undoManager) {
                this.editor.composer.undoManager.clearHistory();
            }
        }
    };

    /**
     * Fetches the current html from Rich Text Editor
     * @returns html from Rich Text Editor
     */
    RichTextEditor.prototype.getRichTextEditorContent = function () {
        var html = ns.util.HtmlUtils.richTextEditorToHtml(this.editor.getValue(), this.editorConfig);
        return ns.util.HtmlUtils.wrapInBody(html);
    };

    /**
     * Executes command(bold,italics,etc) on the Editor
     * @param command Name of the command
     * @param value value for the command
     * @param allowUndo whether undo to be enabled for the command or not
     */
    RichTextEditor.prototype.executeCommand = function (command, value, allowUndo) {
        if (arguments && arguments.length > 0) {
            if (this.editor && this.editor.composer) {
                this.editor.composer.commands.exec.apply(this, arguments, allowUndo);
            } else {
                window.console.error("Unable to find the Editor instance");
            }
        } else {
            window.console.error("Invalid command ");
        }
    };

    /**
     * Changes the toolbar mode
     * @param e Toolbar mode change Event
     * @param mode Mode for the toolbar to be enabled
     */
    RichTextEditor.prototype.toggleToolbarMode = function (e, mode) {
        this.$element.removeClass("rte-mode-" + this.toolbar.getMode());
        if (this.$toolbar) {
            $(this.toolbar).off("modeChanged");
            this.$toolbar.detach();
        }
        this.$toolbar = this.toolbar.setMode(mode);
        this.$element.prepend(this.$toolbar);
        this.$element.addClass("rte-mode-" + this.toolbar.getMode());
        this.editor.setToolbar(this.$toolbar[0]);
        this.toolbar.initializeToolbarEvents(this);
        $(this.toolbar).on("modeChanged", $.proxy(this.toggleToolbarMode, this));
    };

    RichTextEditor.addCommand = function (commandName, options) {
        wysihtml5.commands[commandName] = options;
    };

})(document, $, Form.rte);


/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2016 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/

window.xfalib.$ = window.$;
window.xfalib.jQuery = window.jQuery;
window.xfalib._ = window._;
/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *   ___________________
 *
 *    Copyright 2013 Adobe Systems Incorporated
 *    All Rights Reserved.
 *
 *   NOTICE:  All information contained herein is, and remains
 *   the property of Adobe Systems Incorporated and its suppliers,
 *   if any.  The intellectual and technical concepts contained
 *   herein are proprietary to Adobe Systems Incorporated and its
 *   suppliers and are protected by all applicable intellectual property
 *   laws, including trade secret and copyright laws.
 *   Dissemination of this information or reproduction of this material
 *   is strictly forbidden unless prior written permission is obtained
 *   from Adobe Systems Incorporated.
 ******************************************************************************/


;(function ($) {
    /*
     * Form Bridge API
     * The API provides a method for external applications to connect with Xfa and formDom. The APIs are divided into two categories, synchronous and asynchronous.
     *
     * All the APIs that are internal to us must go into FormBridgeInternal.js and not here
     *
     * Each Synchronous getter API returns a XFAResultObject which represents the result of the API whereas each setter API throws an exception in case of error and
     * it is the responsibility of the API to catch those exceptions. The XFAResultObject either contains error or the return value of the API and provides easy
     * mechanism to access each of them.
     *
     * Each Asynchronous API provides callback mechanism to return the result of the API. Each API takes a Javascript Object containing error, success Handlers and a
     * context in which to invoke those functions. The syntax of the object is
     * { error: errorHandlerFunc,
     *   success: successHandlerFunc,
     *   context: ObjectContext
     * }
     * The signature of the functions is
     * function(XFAResultObject) {
     *
     *  }
     * Each of the functions is passed a XFAResultObject containing either the data of the operation or the errors.
     *
     */

    Function.prototype.bind = Function.prototype.bind || function (ctx) {
        var that = this;
        return function () {
            that.call(ctx, arguments);
        }
    };

    /* public interface XFAResultObject
     public string[] message          // error messages
     public string[] somExpression    // somExpressions that caused the errors
     public string[] errorCode        // internal
     public bool errors               // whether the result object has errors or not
     public Object data               // data returned by the function

     public getNextMessage            // returns a message Object {code,somExpression,message} or null if no error message is present
     */
    var XFAResultObject = function() {
        var _message = [],
            _errorCode = [],
            _somExpression = [];
        this.errors = false;

        this.addMessage = function (code, msg, som) {
            this.errors = true;
            _message.push(msg);
            _somExpression.push(som);
            _errorCode.push(code);
        };

        this.getNextMessage = function () {
            if (_errorCode.length == 0)
                return null;
            return {
                code: _errorCode.pop(),
                somExpression: _somExpression.pop(),
                message: _message.pop()
            };
        };
    };

    var FORM_BRIDGE_VERSION = "8.1.36";
    var FormBridge = function () {
        this._xfa = null;
        this._version = FORM_BRIDGE_VERSION;
        this._xfaInitHandler = {};
        this._$target = null;
        this.isAnalyticsEnabled = false;
        $(window).on("XfaInitialized", this._xfaInitialized.bind(this));
        $(window).on("XfaInitializationError", this._xfaError);
        this._formDoc = window.document;
        this.userConfig = {};
        // indicates if ajax call is executed in client or server
        // note: this should not be modified in client
        this.ajaxCallMode = "client";
        this._PROFILE_RESOURCE_PATH = "/content/xfaforms/profiles/default";
    };

    /*
     * Default error handler for functions in case none is provided by the caller
     * TODO : make the string localized and call the xfa Logger
     */
    var defaultErrorHandler = function (obj) {
        if (typeof(console) == "undefined")
            return;
        var d = null;
        while (d = obj.getNextMessage())
            console.error(d.message);
    };

    var _isFirstTempStorageCreationPending = false,
        TEMP_STORAGE_PATH = "/tmp/fd/xfaforms";
    var createUUIDStorage  = function(uuid){
        if(!formBridge._isLoginAnonymous()) {
            var successFlag = true;
            $.ajax({
            url: formBridge._getPathUrl(".fd.tempstorageprovider.jsp"),
                type: "POST",
                async: false,
                data: {"uuidPath": TEMP_STORAGE_PATH + "/" + uuid},
                error : function (message) {
                    successFlag = false;
                }
            });
            return successFlag;
        }

    };

    /*
     * Default function to check Validations errors after getting the data from the
     * server with getDataXML call.
     */
    var defaultValidationChecker = function (validations, obj) {
        if (validations && validations.length > 0) {
            for (var i = 0; i < validations.length; i++)
                obj.addMessage(0, validations[i], "");
            return false;
        }
        return true;
    };

    $.extend(FormBridge.prototype, {
        /*
         * Returns whether Form Dom is initialized or not.
         */
        isConnected: function () {
            return !!this._xfa;
        },
        /*
         * @public
         * Specify a function to execute after making a connection with FormBridge
         * handler: handler to execute
         * context: variable 'this' will refer to context in the handler.
         */
        connect: function (handler, context) {
            context = context || formBridge;
            if (this.isConnected())
                handler.call(context);
            else {
                this._xfaInitHandler.handler = this._xfaInitHandler.handler || [];
                this._xfaInitHandler.handler.push(handler);
                this._xfaInitHandler.context = this._xfaInitHandler.context || [];
                this._xfaInitHandler.context.push(context);
            }
        },
        /*
         * @private
         * Handler for XfaInitialized event which is fired by XFA library after Form Dom is initialized
         */
        _xfaInitialized: function (e) {
            this._xfa = xfalib.runtime.xfa;
            var obj = new XFAResultObject();
            if (this.storage) {
                if (this.storage.formState) {
                    this._xfa.host.playJson(JSON.parse(this.storage.formState.xfaDom));
                    this.storage.success.call(this.storage.context);
                    this.storage = null;
                } else if (this.storage.success) {
                    this.storage.success.call(this.storage.context);
                }
                if (this.xmlStorage && this.xmlStorage.xmlDocument) {
                    try {
                        this._xfa.Logger.debug("xfa", "Restoring Data XML after initiailzation");
                        this._xfa.host.playDataXml(this.xmlStorage.xmlDocument);
                        if(this.xmlStorage.success) {
                            this.xmlStorage.success.call(this.xmlStorage.context, obj);
                        }
                    } catch(e) {
                        if(this.xmlStorage.error) {
                            obj.addMessage(2, "Unexpected Exception: Unable to play Data XML " + e, null);
                            this.xmlStorage.error.call(this.xmlStorage.context, obj);
                        }
                    }
                } else if (this.xmlStorage && this.xmlStorage.success) {
                    this.xmlStorage.success.call(this.xmlStorage.context, obj);
                }
                this.xmlStorage = null;
            }
            if (this._xfaInitHandler.handler) {
                for (var i = 0; i < this._xfaInitHandler.handler.length; i++) {
                    this._xfaInitHandler.handler[i].call(this._xfaInitHandler.context[i]);
                }
                this._xfaInitHandler = {};
            }
        },

        /*
         * @public
         * Specify a function to decide whether the analytics will be enabled or disabled
         * public Boolean isAnalyticsEnabled: this argument determines whether the analytics will be enabled or not
         */
        enableAnalytics: function(state){
            this.isAnalyticsEnabled = state;
        },

        _xfaError: function (e) {
            this._xfa = window.xfa;
            var obj = new XFAResultObject();
            // since there is xfa init error, why should we call playJson
            if (this.storage.formState) {
                this._xfa.host.playJson(JSON.parse(this.storage.formState.xfaDom));
                this.storage = null;
            } else {
                if (this.storage.error)
                    this.storage.error.call(this.storage.context, e.message);
            }
            if (this.xmlStorage.error) {
                obj.addMessage(2, e.message, null);
                this.xmlStorage.error.call(this.xmlStorage.context, obj);
            }
        },

        _getResultObject: function() {
            return new XFAResultObject();
        },

        _checkXfa: function (obj) {
            if (!this._xfa) {
                obj.addMessage(1, "Xfa Dom not Initialized", "");
                return false;
            }
            return true;
        },
        /*
         * returns the version of library
         */
        getBridgeVersion: function () {
            return this._version;
        },

        /*
         * Registers user/portal specific configurations to FormBridge.
         * Currently supported configurations are:
         * {widgetConfig : {selector: jqWidgetName}}
         * {pagingConfig : {pagingEnabled: true}}
         * {LoggerConfig : {{"on":"true", "category":"xfa", "level":"5", "type":"console"}}
         * {postExternalMessageConfig : {postExternalHandler: fn}}
         * {contextPath : contextPath}
         * {viewportWidth : <1000>}
         * e.g.: formBridge.registerConfig("widgetConfig", {".imagefield" : "sigImageField"});
         *
         * returns a XFAResultObject. Old config against same key is stored in obj.data[0]
         */
        registerConfig: function (key, config) {
            var obj = new XFAResultObject();
            obj.data = this.userConfig[key];
            this.userConfig[key] = config;
            obj.completed = true;
            return obj;
        },


        /*
         * Returns the pagingManager handle for the current xfa view.
         * Should be called after FormBridge is in connected mode else paginManager handle would be null
         */
        pagingManager: function () {
            if (this._xfa && this._xfa.host)
                return this._xfa.host.pagingManager;
            else
                return null;
        },

        /*
         * hide the fields whose som is provided in the fieldArray
         * fieldArray: array of somExpressions
         */
        hideFields: function (fieldArray) {
            this.setFieldProperties(fieldArray, "presence", "invisible");
        },
        /*
         * Make the fields, whose som is provided in the fieldArray, visible
         * fieldArray: array of somExpressions
         */
        showFields: function (fieldArray) {
            this.setFieldProperties(fieldArray, "presence", "visible");
        },
        /*
         * set the value of the field. Throws an exception if the somExpression is incorrect
         * field: somExpressions of the field
         */
        setFieldValue: function (field, value) {
            this.setFieldProperties(field, "rawValue", value);
        },
        /*
         * get the value of the fields, whose som is provided in the fieldArray
         * fieldArray: array of somExpressions
         *
         * returns a XFAResultObject. The result is stored in obj.data[0]
         */
        getFieldValue: function (field) {
            return this.getFieldProperties(field, "rawValue");
        },
        /*
         * set the property of the fields, whose som is provided in the fieldArray, with the values provided
         * fieldArray: array of somExpressions
         * prop: property to set
         * values: array of values.
         */
        setFieldProperties: function (fieldArray, prop, values) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                throw obj.getNextMessage().message;

            if (!_.isArray(fieldArray)) {
                fieldArray = [fieldArray];
            }

            if (!_.isArray(values)){
                values = [values];
            }

            for (var i = 0; i < fieldArray.length; i++) {
                var field = this._xfa.resolveNode(fieldArray[i]);
                if (field == null)
                    throw "No field " + fieldArray[i] + " exists"
                else {
                    obj.completed = true;
                    field[prop] = values[i] || values[0];
                }
            }
            // change made to re-evaluate floating field text in draw
            if(prop && prop === "rawValue" && this._xfa.moContextNodes.length == 0) {
                this._xfa.runCalcAndValidate();
            }
        },
        /*
         * get the property value of the fields, whose som is provided in the fieldArray
         * fieldArray: array of somExpressions
         * prop: property to get
         *
         * returns a XFAResultObject whose data member is the array of returned values. If a
         * somExpression provided doesn't exists null is returned for that element in the data
         */
        getFieldProperties: function (fieldArray, prop) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                return obj;

            if (!_.isArray(fieldArray)) {
                fieldArray = [fieldArray];
            }

            obj.data = [];
            for (var i = 0; i < fieldArray.length; i++) {
                var field = this._xfa.resolveNode(fieldArray[i]);
                if (field == null) {
                    obj.addMessage(0, "No field " + fieldArray[i] + " exists", fieldArray[i])
                    obj.data.push(null);
                }
                else {
                    obj.completed = true;
                    obj.data.push(field[prop]);
                }
            }
            return obj;
        },
        hideSubmitButtons: function () {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                throw obj.getNextMessage().message;
            this._xfa._hideSubmitButtons();
        },
        _getPathUrl: function (urlSuffix) {
            var url = this._PROFILE_RESOURCE_PATH + (urlSuffix || "");
            return this._getUrl(url);
        },

        _getFileWidgetIfPresent: function () {
            return xfalib.runtime.fileUploadWidget;

        },
        _getFileListFromFileWidget:  function () {
            var fileWidget = this._getFileWidgetIfPresent();
            if(fileWidget) {
                return fileWidget._getFileList();
            }
            return null;
        },
        _getCommitValueFromFileWidget: function () {
            var fileWidget = this._getFileWidgetIfPresent();
            if(fileWidget) {
                return fileWidget.getCommitValue();
            }
            return null;
        },

        /**
         *
         * @param optimize{boolean} flag to turn optimization on; if false, entire jsonModel is returned,
         * else diff of initial and current model returned.
         * @param optimize_level{0,1 or 2} : determines the aggressiveness level of size optimizations used
         *  0: returns all properties which changed between initial and current model.
         *  1: jsonModelDiff with access & presence, must be repayable via playJson on calling restoreFormState. but to keep diff sz to min.
         *      remove unplayed items from the diff. Also to maintain hierarchy must have all instance managers, and unbinded fields.
         *  2: minimal jsonModelDiff with only hierarchy skeleton and class, name and 'value's preserved for transfer during submit.
         *
         * @returns {XFAResultObject}
         * returns the string representation of the XFA Form DOM and includes all the XFA packets
         * returns a XFAResultObject whose 'data' member is the formState
         */
        getFormState: function (optimize, optimize_level) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj)) {
                return obj;
            }
            var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
            //To maintain backward compatibility
            if (behaviorConfig.isOn('disableLeanSubmit') || behaviorConfig.isOn('mfDisableLeanSubmit')) {
                optimize_level = 0;
            }
            var xfaDom = optimize === true ? this._xfa._computeJsonDiff(optimize_level).jsonDifference
                                           : this._xfa.jsonModel;

            xfaDom.isComplete = !optimize;

            //add the information required from DOM during submit in the form state
            var formAttributesData = {},
                formElement = $("#lcforms_xfaform_container")[0];
            if(formElement){
                _.each(formElement.attributes,function(attrib){
                    formAttributesData[attrib.name] = attrib.value;
                });
            }

            var additionalSubmitInformation = {
                "formAttributesData": formAttributesData,
                "userConfig": formBridge.userConfig
            };

            var xfaDomString = JSON.stringify(xfaDom);
            obj.data = {
                xfaDom: xfaDomString,
                //save renderContext in form state to enable deferred submit even if form is not open
                renderContext: xfalib.runtime.renderContext,
                customPropertyMap: xfalib.runtime.customPropertyMap,
                additionalSubmitInformation: additionalSubmitInformation
            };
            return obj;
        },
        /*
         * sets the field on focus whose somExpression is provided
         *
         * throws an exception in case of error.
         */
        setFocus: function (som) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                throw obj.getNextMessage().message;
            var node = this._xfa.resolveNode(som);
            if (node == null) {
                throw "No field " + som + " exists ";
            }
            else {
                this._xfa.host._setFocus(som);
            }
        },

        /*
         *  Helper function to ger submit service proxy url
         */
        _getSubmitServiceProxyUrl: function () {
            var submitServiceProxyConfig = this.userConfig["submitServiceProxyConfig"],
                submitServiceProxyUrl = "",
                contextPath = this.userConfig["contextPath"];
            if (submitServiceProxyConfig && submitServiceProxyConfig["submitServiceProxy"]) {
                submitServiceProxyUrl += submitServiceProxyConfig["submitServiceProxy"];
            }
            else {
                //finally hard code it
                submitServiceProxyUrl += ((contextPath && contextPath !== "/") ? contextPath : "") + "/content/xfaforms/profiles/default.submit.html";
            }
            return submitServiceProxyUrl;
        },

        /*
         * remote invocation ----
         * This method post form dom to LCFormsService and run the success handlers
         * It accepts the object with following params:
         * {
         *  url: '',
         *  type: '',
         *  contentType: '',
         *  data: '',
         *  success: '',
         *  error: ''
         *  }
         *  The called can choose to override one of more parameters of $.ajax API of JQuery
         */

        _invokeAtServer: function (options) {
            options = options || {};
            var submitServiceProxyUrl = this._getSubmitServiceProxyUrl(),
                isServerAjaxCallMode = this.ajaxCallMode === "server";

            if (options.data && !options.data["_charset_"]) {
                options.data["_charset_"] = "UTF-8"; //to let sling know data encoding
            }

            if(isServerAjaxCallMode){
                var mergedFormDom = "";
                // Done to fix: LC-9204
                // Not invoking HTTP request instead making use of server session
                try {
                    mergedFormDom = getMergedFormDomFromRhino(options.data);
                } catch(exception){
                    xfalib.runtime.xfa.Logger.error("xfa", exception.message);
                }
                // If success handler is present, invoke it, context is provided by the caller
                if(_.isFunction(options.success) && mergedFormDom) {
                    options.success(JSON.parse(mergedFormDom));
                }
            } else {
                var strContent = this.getMultipartData(options.data);  // TODO : maybe use the browser's FormData object, and handle IE as we are doing now
                options.data = strContent[1];
                var params = _.extend({
                        beforeSend: formBridge.uiFreeze,
                        complete: formBridge.uiUnFreeze,
                        async: false,
                        url: submitServiceProxyUrl,
                        type: 'POST',
                        processData: false,
                        cache: false,
                        contentType: "multipart/form-data; charset=UTF-8; boundary=" + strContent[0]
                    },
                    options);

                $.ajax(params);
            }
        },

        /**
         *
         * This function does following:
         * a) On first call, it creates the uuid storage and returns the UUID
         * b) On subsequent calls, it just returns the uuid
         * c) if uuid is not created then it returns null
         *
         */
        _getUUID: function () {
            if(this._formInstanceUUID) {
                return this._formInstanceUUID;
            }
            //Generate the UUID for the form instance on client side
            var uuid = $('body#formBody').data("tmproot"),
                uuidSuffix = Math.floor((Math.random() * 10000) + 1),
                uuidCurrentTime = new Date().getTime(),
                successFlag = true;
            this._formInstanceUUID = uuid + "_" + uuidCurrentTime + uuidSuffix;
            successFlag = createUUIDStorage(this._formInstanceUUID);
            if(successFlag){
                return this._formInstanceUUID;
            } else {
                return null;
            }
        },
        _getUrl: function (url) {
            //url provided can contain the hostname and port too, in that case return the url as it is
            if (url.indexOf("http:") == 0 || url.indexOf("https:") == 0) {
                return url;
            }
            var baseUrl = this.userConfig["baseUrl"],
                contextPath = this.userConfig["contextPath"];
            if (baseUrl) {
                return baseUrl + url;
            }
            else if (contextPath && contextPath!== "/" && url.indexOf(contextPath)!== 0 &&(url.length ===0 || url.indexOf("/") === 0)){
                //if url does not have contextPath and starts with /, pre-pend contextPath
                // Also url.length check because I need to pass "" to getUrl and get context path
                return contextPath + url;
            }
            return url;
        },
        getFileAttachmentsInfo: function (options) {
            var fileAttachmentsList = [],
                list;


            function collectFileUrls(event) {
                list = [];
                //TODO: need to modularize collectFileUrs()
                // here this is the context of the function who calls it
                _.each(this.attachments, function (att) {
                    //this.fileUrl is null when no file is uploaded. att contains path - "fileupload/™a.jpg" if not uploaded
                    // if att starts with "/", this means that the attachment has already been uploaded.
                    if(!_.isEmpty(this.fileUrl) && att.indexOf("/")!=0 ) {
                        list.push({name: att.split("/")[1], path: this.fileUrl + "/" + att});
                    } else {
                        list.push({name: att.substring(att.lastIndexOf("/")+1), path: att});
                    }
                }, this);
                if (this.options.success) {
                    this.options.success.call(this.options.context, list);
                }
            }

            this._getAttachments(fileAttachmentsList, options.fileUploadPath || this.getTempPath(), collectFileUrls, options);

        },

        _getAttachments: function (fileAttachmentDomElement, fileUploadPath, callback, options) {

            var allFiles = [],
                attachments = [],
                fileUrl = null,
                fileCount = 0,
                didSubmit = false,
                contextRoot = this._getContextRoot(),
                FILE_COMPONENT_NAME = "fileupload";

            /*
             * In the case of draft, url comes with context root. Need to remove it so that correct value gets stored in model
             */
            if (contextRoot) {
                if (fileUploadPath.indexOf(contextRoot) === 0) {
                    fileUploadPath = fileUploadPath.substring(contextRoot.length);
                }
            }

            var currentCount = 0;
            var fileNameList = formBridge._getCommitValueFromFileWidget();

            if (fileNameList.length > 0) {
                var fileNames = fileNameList;
                var fileList = $.extend(true, [], formBridge._getFileListFromFileWidget());
                _.each(fileList, function (file, index) {
                    var nameOfFile = fileNames[index],
                        completeNameOfFile = null;
                    if (nameOfFile != null && file != null) { //file can be null when you click save two times continuously without change in guide context
                        completeNameOfFile = FILE_COMPONENT_NAME + "/" + nameOfFile;
                        // case: if there is a file dome
                        if (!_.isString(file)) {
                            // Check if the value exist in the file, this is done because in IE9 and IE10 the list will
                            // have an extra empty dom
                            if ($(file).val().length > 0) {
                                $(file).attr('name', completeNameOfFile);
                                attachments[fileCount] = completeNameOfFile;
                                allFiles[fileCount++] = $(file);
                            }
                        } else {
                            // since there is no file dom in case of draft usecase, make it null
                            attachments[fileCount] = file;
                            allFiles[fileCount++] = null;
                        }
                    }
                }, this);


                if (allFiles.length > 0) {

                    // since there can be a dom element which is null, in case of draft usecase
                    // get the first non null file dom
                    var firstNonNullFileDom = _.indexOf(allFiles, _.find(allFiles, function (item) {
                        return item !== null;
                    }));
                    var uploaderPluginName = formBridge.userConfig.uploaderPluginName || "adobeFileUploader";
                    if (firstNonNullFileDom !== -1) {
                        fileUrl = allFiles[firstNonNullFileDom][uploaderPluginName]("uploadFile", {
                            'fileName': attachments,
                            'fileDom': allFiles,
                            'fileUploadPath': fileUploadPath,
                            'multiple': true,
                            '_uuidGenerator': function () { return formBridge._getUUID.apply(this); },
                            _getUrl: formBridge._getUrl("")
                        });

                        /*The file url returned by file upload widget can contain context root. Remove it so that correct value gets stored in model.*/
                        if (contextRoot) {
                            if (fileUrl.indexOf(contextRoot) === 0) {
                                fileUrl = fileUrl.substring(contextRoot.length);
                            }
                        }

                        allFiles[firstNonNullFileDom].one("adobeFileUploader.multipleFileUploaded", $.proxy(callback,
                            {
                                "attachments": attachments,
                                "fileUrl": fileUrl,
                                "options": options,
                                "_uuidGenerator": function () { return formBridge._getUUID.apply(this); }
                            })
                        );
                        didSubmit = true;
                    }
                }

            }

            if (!didSubmit) {
                // if there are no files attached, still call the callback to submit the json contents
                // if there is only one file attachment component with no files, in this case else is important
                callback.apply({
                    "attachments": attachments,
                    "fileUrl": fileUrl,
                    "options": options
                });

            }

        },
        _isFileAttachmentEnabled: function () {
            return xfalib.runtime.renderContext.mfAllowAttachments === 'true';
        },
        _isLoginAnonymous: function (value) {
            var flag;
                if(xfalib.runtime) {
                    flag = xfalib.runtime._isAnonymous;
                    if(_.isUndefined(value)) {
                        return flag;
                    }
                    xfalib.runtime._isAnonymous = value;
                    return flag;
                }
        },

        _getContextRoot: function() {
            return this.userConfig["contextPath"];
        },

        getTempPath: function() {
            return "/tmp/fd/xfaforms/" + this._getUUID();
        },
        _getFileNamePathMap: function(valueList) {
            var fileWidget = this._getFileWidgetIfPresent();
            if(fileWidget) {
                return fileWidget._getFileNamePathMap(valueList);
            }
            return {};
        },






        getMultipartData: function (data) {
            //Start multipart formatting
            var initBoundary = this.randomString();
            var strBoundary = "--" + initBoundary;
            var strMultipartBody = "";
            var strCRLF = "\r\n";

            //Create multipart for each element of the form
            for (var key in data) {
                if (data.hasOwnProperty(key)) {
                    var value = typeof data[key] == "string" ? data[key] : JSON.stringify(data[key]);
                    strMultipartBody +=
                        strBoundary
                        + strCRLF
                        + "Content-Disposition: form-data; name=\"" + key + "\""
                        + strCRLF
                        + strCRLF
                        + value
                        + strCRLF;
                }
            }
            //End the body by delimiting it
            strMultipartBody += strBoundary + "--" + strCRLF;
            //Return boundary without -- and the multipart content
            return [initBoundary, strMultipartBody];
        },

        randomString: function () {
            var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
            var string_length = 8;
            var randomString = '';
            for (var i = 0; i < string_length; i++) {
                var rnum = Math.floor(Math.random() * chars.length);
                randomString += chars.substring(rnum, rnum + 1);
            }
            return randomString;
        },

        /*
         * returns the input data in XML Form. The call is asynchronous and recieves the following options apart from the default
         * ones provided earlier
         *      validationChecker //function to call for checking validation errors received from server
         *                          The signature for the functions is
         *                              function(validations)
         *                              {
         *                                  // validations is an array of error strings.
         *                              }
         *      formState       // The state of the XFA Form, if saved by the user, otherwise the current one
         */
        getDataXML: function (options) {
            options = options || {};
            var obj = new XFAResultObject();
            if (!options.formState && !this._checkXfa(obj)) {
                options.error.call(options.context, obj);
                return;
            }
            if(!options.formState && xfalib.ut.XfaUtil.prototype.getOrElse(xfalib.runtime, "customPropertyMap.xmlOnClient", "0") === "1") {
                try {
                    var xml = this.generateDataXML();
                    obj.data = xml;
                    if (options.success) {
                        options.success.call(options.context, obj);
                    }
                } catch(exception) {
                    var msg = "Unable to generate xml on client. Use Server option to generate the xml. " + exception;
                    this._xfa.Logger.error("xfa", msg);
                    obj.completed = false;
                    obj.addMessage(2, msg, "");
                    if(options.error) {
                        options.error.apply(options.context, [obj]);
                    }
                }
                return;
            }
            var formState = options.formState || this.getFormState(true, 2).data;
            //clone the object to avoid polluting the old copy
            var params = _.extend({formDom: formState.xfaDom, requestDataXml : "true"}, formState.renderContext);
            this._invokeAtServer({
                data: params,
                dataType: 'text',
                success: function (result) {
                    obj.completed = true;
                    if (!result) {
                        obj.addMessage(0, "There was an error in getting data xml", "");
                        options.error.call(options.context, obj);
                        return;
                    }
                    obj.data = result;
                    if (options.validationChecker) {
                        if (!options.validationChecker.call(options.context, result.validationErrors)) {
                            options.error.call(options.context, obj);
                            return;
                        }
                    }
                    if (options.success)
                        options.success.call(options.context, obj,formState);
                },
                error: function (xhr, txtStatus, errorThrown) {
                    var msg = formBridge._getDataXMLError(xhr, txtStatus, errorThrown);
                    obj.completed = false;
                    obj.addMessage(2, msg, "");
                    if (options.error) {
                        options.error.call(options.context, obj);
                    }
                    if (formBridge._xfa) {
                        formBridge._xfa.host.messageBox(msg);
                    }
                }
            });
        },

        _getDataXMLError: function (xhr, txtStatus, errorThrown) {
            var msg;
            switch (xhr.status) {
                case 0:
                    msg = xfalib.locale.LogMessages["ALC-FRM-901-008"];
                    if(this._xfa) {
                        this._xfa.Logger.error("xfa", msg + " " + xhr.statusText);
                    }
                    break;
                default:
                    msg = xfalib.locale.LogMessages["ALC-FRM-901-016"];
                    if(this._xfa) {
                        this._xfa.Logger.error("xfa", msg + " " + xhr.statusText);
                    }
                    break;
            }
            return msg;

        },

        _identifyConnectionError: function (xhr, txtStatus) {
            var msg = "";
            switch (xhr.status) {
                case 0:
                    msg = xfalib.locale.LogMessages["ALC-FRM-901-008"];
                    if(this._xfa) {
                        this._xfa.Logger.error("xfa", msg + " " + xhr.statusText);
                    }
                    break;
                case 404:
                    msg = xfalib.locale.LogMessages["ALC-FRM-901-008"];
                    if(this._xfa) {
                        this._xfa.Logger.error("xfa", msg + " " + xhr.statusText);
                    }
                    break;
            }
            return msg;


        },

        _getAllowAttachmentsFromFormState: function (formState) {
            return formState.renderContext.mfAllowAttachments === 'true';
        },

        /**
         * @public
         * This performs an ajax submit to a url.
         * This API creates a form data object and submits this object.
         * @param options
         */
        doAjaxSubmit: function(options){

            if(window.FormData){

                var psuedoForm = $("<form>"),
                    formState = options.formState || this.getFormState(true, 2).data,
                    submitServiceProxyConfig = formState.additionalSubmitInformation.userConfig["submitServiceProxyConfig"],
                    action = options.action || this._getSubmitServiceProxyUrl();

                _.each(formState.additionalSubmitInformation.formAttributesData, function (value, key) {
                    psuedoForm.attr(key, value);
                }, this);

                psuedoForm.attr("action", action);
                var $charSetField = $("<input>").attr({"type": "hidden", "name": "_charset_", "value": "UTF-8"});
                $(psuedoForm).append($charSetField);

                _.each(submitServiceProxyConfig, function (fieldValue, fieldName) {
                    var newField = $("<input>").attr("type", "hidden")
                        .attr("name", fieldName)
                        .val(fieldValue);
                    $(psuedoForm).append($(newField));
                });

                //clone the object to avoid polluting the old copy
                var params = _.extend({}, formState.customPropertyMap, {formDom: formState.xfaDom}, formState.renderContext);

                for (var param in params) {
                    if (params.hasOwnProperty(param)) {
                        newField = $("<input>").attr("type", "hidden")
                            .attr("name", param)
                            .val(params[param]);

                        $(psuedoForm).append($(newField));
                    }
                }

                var fileAttachmentEnabled = formBridge._getAllowAttachmentsFromFormState(formState);
                if (fileAttachmentEnabled) {
                    if (options.fileAttachmentMap) {
                        var fileAttachmentMapInput = $("<input>").attr("type", "hidden")
                            .attr("name", "fileAttachmentMap")
                            .val(JSON.stringify(options.fileAttachmentMap));
                        $(psuedoForm).append($(fileAttachmentMapInput));
                    } else {
                        var fileAttachmentMap = formBridge._getFileNamePathMap(),
                            fileAttachmentInputs = formBridge._getFileListFromFileWidget(),
                            fileAttachmentMapInput;

                        _.each(formBridge._getCommitValueFromFileWidget(), function (nameOfFile, index) {
                            if (_.isObject(fileAttachmentInputs[index]) && _.isString(nameOfFile) && !nameOfFile.match(/\//g)) {
                                fileAttachmentInputs[index].attr("name", nameOfFile);
                                if (!fileAttachmentMap[nameOfFile]) {
                                    fileAttachmentMap[nameOfFile] = "";
                                    $(psuedoForm).append(fileAttachmentInputs[index]);
                                }
                            }
                        });
                        fileAttachmentMapInput = $("<input>").attr("type", "hidden")
                            .attr("name", "fileAttachmentMap")
                            .val(JSON.stringify(fileAttachmentMap));
                        $(psuedoForm).append($(fileAttachmentMapInput));
                    }
                }
                //the XFAResultObject that will be passed to the success and error handler
                var obj = new XFAResultObject();

                var fd = new FormData(psuedoForm[0]);
                //set contentType to false to prevent jquery from setting it to default value
                //Setting processData to false to prevent jQuery from automatically transforming the data into a query string
                // set dataType to "text" to retrieve the xml as string.
                // The ajax call returns dataXml that is passed inside XFAResultObject.
                $.ajax({
                    url: formBridge._getUrl(action),
                    data: fd,
                    processData: false,
                    dataType:'text',
                    contentType: false,
                    type: 'POST',
                    success: function (result) {
                        obj.completed = true;
                        if (!result) {
                            obj.addMessage(0, "There was an error in submitting the form", "");
                            options.error.call(options.context, obj);
                            return;
                        }
                        obj.data = result;
                        if (options.validationChecker) {
                            if (!options.validationChecker.call(options.context, result.validationErrors)) {
                                options.error.call(options.context, obj);
                                return;
                            }
                        }
                        if (options.success) {
                            options.success.call(options.context, obj);
                        }
                    },
                    error: function (xhr, txtStatus, errorThrown) {
                        var msg = formBridge._getDataXMLError(xhr, txtStatus, errorThrown);
                        obj.completed = false;
                        obj.addMessage(2, msg, "");
                        if (options.error) {
                            options.error.call(options.context, obj);
                        }
                        if (formBridge._xfa) {
                            formBridge._xfa.host.messageBox(msg);
                        }
                    }
                });

            } else {
                options.error.call(options.context);
            }
        },

        /*
         * submits the form data to a url provided in Config or Form Template
         * The API calls getDataXML, checks validation errors and either submits the data itself
         * or passes the data to the success handler provided by the caller
         *
         */
        submitForm: function (options) {
            options = options || {};
			options.error = options.error || defaultErrorHandler;
            options.context = options.context || formBridge;
            options.validationChecker = options.validationChecker || defaultValidationChecker;
            //formBridge.keyValuePairSubmission = true;

            this.uiFreeze();   // Bug: LC-6068 To show cursor in wait state and also freezing the ui by marking root subform access as readOnly.
            var originalSuccess = options.success;
            var originalError = options.error || defaultErrorHandler;
            var originalContext = options.context;
            var that = this;

            options.error = (function () {
                return function () {
                    that.uiUnFreeze();  // Bug: LC-6068 To restore cursor from wait state and also restoring the ui by marking root subform access as its old access.
                    if (originalError) {
                        originalError.apply(originalContext, arguments);
                    }
                };
            })();
            var obj = new XFAResultObject();

            // if cancelAction property is set to true in preSubmit, execPreSubmit return false
            if (this._xfa && this._xfa.form.execPreSubmit() == false ) {
                var msg = "Submit cancelled";
                this._xfa.host.messageBox(msg);
                obj.addMessage(0, msg, "xfa");
                options.error.call(options.context, obj);
                return;
            }

            if (this._xfa && this._xfa.host._validate() == false) {
                obj.addMessage(0, "client side validations failed", "xfa"); //TODO: handlesomExpression passing
                options.error.call(options.context, obj);
                return;
            } else {
                xfalib.ut.XfaUtil.prototype._triggerOnBridge("submitStart", this, "submit");
            }
            if (options.success /*|| formBridge.keyValuePairSubmission*/) {
                /*var defaultSuccessHandler = function(obj) {
                 var formState = options.formState || this.getFormState().data;
                 //clone the object to avoid polluting the old copy
                 var params = _.extend({formDom: formState.xfaDom}, formState.renderContext);

                 for(var p in params) {
                 var field = $("<input>").attr("type", "hidden").attr("name",p).val(params[p]);
                 $("#lcforms_xfaform_container").append($(field));
                 }
                 var dataField = $("<input>").attr("type", "hidden").attr("name","data").val(obj.data);
                 $("#lcforms_xfaform_container").append($(dataField));

                 var submitServiceProxyConfig = this.userConfig["submitServiceProxyConfig"];
                 var submitUrl = options.action || submitServiceProxyConfig.submitUrl;
                 $("#lcforms_xfaform_container").attr("action", submitUrl);
                 $("#lcforms_xfaform_container").submit();
                 }
                 options.success = options.success || defaultSuccessHandler*/
                //Submit from form bridge api

                options.success = (function () {
                    return function () {
                        that.uiUnFreeze();  // Bug: LC-6068 To restore cursor from wait state and also restoring the ui by marking root subform access as its old access.
                        if (originalSuccess) {
                            originalSuccess.apply(originalContext, arguments);
                        }
                    };

                })();
                formBridge.doAjaxSubmit(options);
            }
            else {
                //Always submit form state to submitServiceProxy and then the proxy will in-turn submit the data xml to the submitUrl on behalf of MobileForm
                //create a psuedo form element and do submission
                var cont = true;
                var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
                //To maintain backward compatibility
                if (!behaviorConfig.isOn('disableHeadRequest') && !behaviorConfig.isOn('mfDisableHeadRequest')) {
                    $.ajax({
                        async: false,
                        url: this._getSubmitServiceProxyUrl(),
                        type: 'HEAD',
                        complete: function (xhr, txtStatus) {
                            var msg = formBridge._identifyConnectionError(xhr, txtStatus);
                            if (msg) {
                                obj.completed = false;
                                obj.addMessage(2, msg, "");
                                if (options.error) {
                                    options.error.call(options.context, obj);
                                }
                                if (formBridge._xfa) {
                                    formBridge._xfa.host.messageBox(msg);
                                }
                                cont = false
                            }
                        }
                    });
                }

                if (cont) {
                    var action = this._getSubmitServiceProxyUrl();

                    var submitServiceProxyConfig = this.userConfig["submitServiceProxyConfig"];

                    var psuedoForm = $("<form>");

                    var formState = options.formState || this.getFormState(true, 3).data;

                    //add the additionalInformation
                    _.each(formState.additionalSubmitInformation.formAttributesData,function(value,key){
                        psuedoForm.attr(key, value);
                    },this);

                    //override action
                    psuedoForm.attr("action", action);

                    //Add _charset_ to let sling know that it should decode in UTF-8
                    var $charSetField = $("<input>").attr("type", "hidden").attr("name", "_charset_").val("UTF-8");
                    $(psuedoForm).append($charSetField);

                    behaviorConfig = this.userConfig["behaviorConfig"];

                    //add supporting fields to psuedo form
                    submitServiceProxyConfig.submitUrl = options.action || submitServiceProxyConfig.submitUrl;
                    for (var fieldName in submitServiceProxyConfig) {
                        if (submitServiceProxyConfig[fieldName]) {
                            var newField = $("<input>").attr("type", "hidden")
                                .attr("name", fieldName)
                                .val(submitServiceProxyConfig[fieldName]);

                            $(psuedoForm).append($(newField));
                        }
                    }
                    var fileAttachmentEnabled = formBridge._isFileAttachmentEnabled();
                    if (!fileAttachmentEnabled) {

                        //clone the object to avoid polluting the old copy
                        var params = _.extend({}, formState.customPropertyMap, {formDom: formState.xfaDom}, formState.renderContext);

                        for (var param in params) {
                            if (params[param]) {
                                var newField = $("<input>").attr("type", "hidden")
                                    .attr("name", param)
                                    .val(params[param]);

                                $(psuedoForm).append($(newField));
                            }
                        }

                        //for IE as you cannot submit a form without attaching it to document.
                        $("#lcforms_xfaform_container").append($(psuedoForm));
                        $(psuedoForm).submit();

                    } else {

                        var fileAttachmentMap = formBridge._getFileNamePathMap(),
                            fileAttachmentInputs = formBridge._getFileListFromFileWidget(),
                            fileAttachmentMapInput ;
                        //clone the object to avoid polluting the old copy
                        params = _.extend({}, formState.customPropertyMap, {formDom: formState.xfaDom}, formState.renderContext);

                        for (param in params) {
                            if (params[param]) {
                                var newField = $("<input>").attr("type", "hidden")
                                    .attr("name", param)
                                    .val(params[param]);

                                $(psuedoForm).append($(newField));
                            }
                        }
                        _.each(formBridge._getCommitValueFromFileWidget(), function (nameOfFile, index) {
                            if( _.isObject(fileAttachmentInputs[index]) && _.isString(nameOfFile) && !nameOfFile.match(/\//g)) {
                                fileAttachmentInputs[index].attr("name", nameOfFile);
                                if(!fileAttachmentMap[nameOfFile]) {
                                    fileAttachmentMap[nameOfFile] ="";
                                    $(psuedoForm).append(fileAttachmentInputs[index]);
                                }
                            }
                        });
                        fileAttachmentMapInput =  $("<input>").attr("type", "hidden")
                            .attr("name", "fileAttachmentMap")
                            .val(JSON.stringify(fileAttachmentMap));
                        $(psuedoForm).append($(fileAttachmentMapInput));

                        //for IE as you cannot submit a form without attaching it to document.
                        $("#lcforms_xfaform_container").append($(psuedoForm));
                        $(psuedoForm).submit();

                    }
                }
            }
            //if submit is successful, we navigate to another page so no need to call uiUnFreeze.
        },

        uiFreeze: function () {
            var $xfa_ui_freeze = $('#lcforms_xfaform_container > #xfa_ui_freeze');
            if ($xfa_ui_freeze.length > 0) {
                $xfa_ui_freeze.show()
            } else {
                $('#lcforms_xfaform_container').append('<div id="xfa_ui_freeze"></div>');
            }
        },

        uiUnFreeze: function () {
            $('#lcforms_xfaform_container > #xfa_ui_freeze').hide();
        },

        /**
         * Get all the fields in the form.
         * @param filter filter function to tell which fields to return. The
         *               function will be passed each field in the form and if
         *               it returns true the field will be returned otherwise not.
         *               **Doesn't return Master Page Fields**
         *               **Renders all pages in the process**
         * @return {Array}
         */
        getAllFields: function (filter) {
            var allFields = [];
            for (var page = 0; page < this._xfa.layout.pageCount(); page++) {
                var pageFields = this._xfa.layout.pageContent(page, "field");
                for (var i = 0; i < pageFields.length; i++) {
                    var field = pageFields.item(i);
                    if (_.isUndefined(filter) || _.isNull(filter) || filter.apply(window, [field]) === true) {
                        allFields.push(field);
                    }
                }
            }
            return allFields;
        },

        /**
         * Get the current field in focus.
         * @return {*}
         */
        getFocus: function () {
            if (this._xfa.host.getFocus) {
                var obj = this._xfa.host.getFocus();
                if (obj)
                    return this._xfa.host.getFocus().somExpression;
                return null;
            }
            else
                return "unsupported";
        },

        /*
         * Validate the form.
         * Run client side validations.
         *
         *
         */
        validateForm: function (options) {
            options = options || {};
            options.error = options.error || defaultErrorHandler;
            options.context = options.context || this;
            var valMessages = [];
            var validationsValue = this._xfa.host._validate({
                valMessages: valMessages
            });

            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                throw obj.getNextMessage().message;

            if (validationsValue == false) {
                obj.addMessage(0, "client side validations failed", "xfa");
                _.each(
                    _.filter(valMessages, function (msg) {
                        return msg.severity === "error"
                    }),
                    function (msg) {
                       obj.addMessage(1, msg.message, msg.ref)
                    }
                );
                options.error.call(options.context, obj);
            }
            else if (options.success)
                options.success.call(options.context, obj);

            return validationsValue;
        },
        //--checking for browser compatibility
        _isBrowserCompatible: function () {
            var isWin = false;
            var isMac = false;
            var isiPad = false;
            var isAndroid = false;
            var isWebKit = false;
            if (navigator.appVersion.indexOf("Win") != -1)
                isWin = true;
            else if (navigator.appVersion.indexOf("Mac") != -1)
                isMac = true;
            else if (navigator.userAgent.match(/iPad/i) != null)
                isiPad = true;
            else if (navigator.userAgent.toLowerCase().indexOf("android") > -1)
                isAndroid = true;
            if (navigator.userAgent.toLowerCase().indexOf("webkit") > -1)
                isWebKit = true;

            var browserVersion = parseInt($.browser.version, 10);
            if (isWin && ($.browser.msie && (browserVersion == 6 || browserVersion == 7 || browserVersion == 8)))
                return false;
            else if (isWin && (isWebKit || $.browser.mozilla || ($.browser.msie && (browserVersion == 9 || browserVersion == 10)))) {
                return true;
            }
            else if ((isMac || isiPad || isAndroid) && isWebKit) {
                return true;
            }
            else {
                return false;
            }
        },
        /*
         * Restores the Form State to a previous state. This is a Asynchronous call and recieves a formState from the
         * caller. The state will be applied and success or error handlers will be called after the operation is
         * completed.
         */
        restoreFormState: function (options) {
            if (window.atob && options.base64FormState !== undefined) {
                // Decode base 64 encoded string to form the form DOM object.
                var utftext = atob(options.base64FormState),
                    string = "",
                    i = 0,
                    c = 0,
                    c1 = 0,
                    c2 = 0,
                    c3 = 0;
                while ( i < utftext.length ) {
                    c = utftext.charCodeAt(i);
                    if (c < 128) {
                        string += String.fromCharCode(c);
                        i++;
                    }
                    else if((c > 191) && (c < 224)) {
                        c2 = utftext.charCodeAt(i+1);
                        string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                        i += 2;
                    }
                    else {
                        c2 = utftext.charCodeAt(i+1);
                        c3 = utftext.charCodeAt(i+2);
                        string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                        i += 3;
                    }
                }
                utftext = string;
                var formDom = JSON.parse(utftext);
                options.formState = formDom;
            }

            /*
             * We have to merge the runtime renderContext with the renderContext of the formState passed
             * so that no custom properties that were set in the context(present in the form state) are ignored.
             */
            xfalib.runtime.renderContext = xfalib.runtime.renderContext || {};
            _.extend(xfalib.runtime.renderContext, options.formState.renderContext);
            if (!this._xfa) {
                this.storage = {};
                this.storage.formState = options.formState;
                this.storage.error = options.error;
                this.storage.success = options.success;
                this.storage.context = options.context;
            } else {
                this._xfa.host.playJson(JSON.parse(options.formState.xfaDom));
                this.customContextProperty(options.formState.customPropertyMap);
                if(_.isFunction(options.success)) {
                    options.success.call(this);
                }
            }
        },
        customContextProperty: function(property,value) {
            var customPropertyMap = xfalib.runtime.customPropertyMap || {};
            if(_.isUndefined(value)) {
                if(_.isObject(property)) {
                    _.extend(customPropertyMap, property);
                    xfalib.runtime.customPropertyMap=customPropertyMap;
                } else {
                return customPropertyMap[property];
                }
            } else {
                var oldValue = customPropertyMap[property];
                customPropertyMap[property]=encodeURIComponent(value);
                xfalib.runtime.customPropertyMap=customPropertyMap;
                return oldValue;
            }
        },
        /*
         * @private
         */
        _getStorage: function () {
            var s = null;
            if (this.storage) {
                var s = this.storage.formState
                this.storage.formState = null;
            }
            return s;
        },

        _getXmlStorage: function () {
            var s = null;
            if (this.xmlStorage) {
                var s = this.xmlStorage.xmlDocument;
                this.xmlStorage.xmlDocument = null;
            }
            return s;
        },

        /*
         * @private
         */
        _getHTMLElement: function (somExpression, full) {
            var obj = this._getHTMLElementInternal(somExpression, full,this._formDoc);
            return obj;
        },

        _getHTMLElementInternal: function(somExpression, full,referenceDocument){
            somExpression = full === true ? somExpression : "xfa[0].form[0]." + somExpression;
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj))
                return obj;
            var elem = this._xfa.resolveNode(somExpression);
            if (_.isEmpty(elem)){
                obj.addMessage(0, somExpression + " not found", somExpression);
            } else {
                var elemId = xfalib.ut.XfaUtil.prototype.jqId(elem.htmlId);
                $(elemId, referenceDocument).children();
                switch (elem.className) {
                    case "instanceManager":
                        obj.addMessage(0, "No HTML Element exists for instanceManagers", somExpression);
                        break;
                    case "subform":
                        obj.data = {elem: $(elemId, referenceDocument)[0]}
                        break;
                    case "field":
                        var data = $(elemId, referenceDocument);
                        var child = data.children();

                        obj.data = {
                            elem: data[0],
                            caption: child[0],
                            widget: { elem: child[1],
                                child: $("input,select", child[1])[0]
                            }
                        };
                        if (!obj.data.widget) {
                            obj.data.widget = {
                                elem: child[0],
                                child: $("input,select", child[0]) [0]
                            }
                        }
                        break;
                    default:
                        obj.data = {elem: $(elemId, referenceDocument)[0]};
                        break;
                }
            }
            return obj;
        },

        _postExternalMessage: function (message) {
            if (this.userConfig["postExternalMessageConfig"] && _.isFunction(this.userConfig["postExternalMessageConfig"]["postExternalHandler"])) {
                var externalHandler = this.userConfig["postExternalMessageConfig"]["postExternalHandler"];
                externalHandler(message);
            }
        },

        scaleForm: function (viewportWidth) {
            if (viewportWidth) {
                this.userConfig["viewportWidth"] = viewportWidth;
                window.xfaViewRegistry.scaleForm();
            }
        },

        /**
         * This function hides the toolbar where required.
         * @memberof FormBridge
         */
        hideToolbar: function(){
          $(".toolbarheader").hide();
        },

        /**
         * Used to Register an event listener for specific Form Bridge Event.
         * @param eventName {string} name of the event for which listener has to be added. It must be one of the events
         * mentioned in the documentation.
         * @param handler {function} event listener which is called when the event is triggered.
         * @param [context] {object} context is used as the <i>this</i> object inside handler function
         */

        on: function (eventName, handler, context) {
            this._$target.on(eventName, handler, context);
        },


        /**
         * Unregister the event registered using the {@link FormBridge.on|on} function
         *
         * @param eventName {string} name of the event to un-register.
         * @param [selector] {string} selector which should match the one originally passed to FormBridge's on() while registering handlers
         * @param [handler] {function} handler which needs to un-registered. If not provided all the event listeners
         * will be unregistered
         */

        off: function (eventName, selector, handler) {
            this._$target.off(eventName, selector, handler);
        },

        /**
         * Internal API
         *
         * @private
         */

        trigger: function (eventName, extraParamerts) {
            if(this.isAnalyticsEnabled || eventName == xfalib.template.Constants.scribbleChangeEvent) {
                this._$target.trigger(eventName, extraParamerts);
            }
        },

        /**
         * constructs the dataSomMap and returns that. If a valid object is provided as the first argument then it
         * modifies and adds entries in that map only, otherwise constructs a new map.
         * @param map {object}
         * @returns {XFAResultObject} with the data parameter as the dataSomMap
         */
        getDataSomMap: function (map) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj)) {
                return obj;
            }
            var _map = map;
            if(!_.isObject(map)) {
                _map = {};
            }
            _map = this._xfa.form._getDataSomMap(_map);
            obj.data = _map;
            return obj;
        },

        /**
         * Updates the field values with the values provided in the map. If map is not an object, returns an error.
         * @param map {object}
         * @return {XFAResultObject} with the data parameter as null.
         */
        restoreDataSomMap: function (map) {
            var obj = new XFAResultObject();
            if (!this._checkXfa(obj)) {
                return obj;
            }
            if(!_.isObject(map)) {
                obj.addMessage(0, "Invalid Argument passed. First argument has to be an object", null);
                return obj;
            }
            this._xfa.form._restoreDataSomMap(map);
            obj.data = null;
            return obj;
        },

        /**
         * Namespace resolver needed for xpath resolution. We need to add more namepsaces
         * @param prefix
         * @returns {*|null}
         */
        nsResolver : function (prefix) {
            var ns = {
                'xfa' : 'http://www.xfa.org/schema/xfa-data/1.0/',
                'xdp' : 'http://ns.adobe.com/xdp/'
            };
            return ns[prefix] || null;
        },

        /**
         * merges the Form with the xmlDocument provided
         * @param options {object} with the folllowing syntax
         *  {
         *   xmlDocument
         *   success: function() {}
         *   error: function(xfaResultObject) {}
         *   context:
         *  }
         * @return {XFAResultObject} with the data parameter as null.
         */
        playDataXML: function(options) {
            if (!this._xfa) {
                this.xmlStorage = {};
                this.xmlStorage.xmlDocument = options.xmlDocument;
                this.xmlStorage.error = options.error || defaultErrorHandler;
                this.xmlStorage.success = options.success;
                this.xmlStorage.context = options.context;
            } else {
                var obj = new XFAResultObject(),
                    options = options || {},
                    error = options.error || defaultErrorHandler,
                    success = options.success,
                    xmlDocument = options.xmlDocument,
                    rootElement;
                if(xmlDocument == null) {
                    obj.addMessage(0, "Invalid Argument Error. XML Document is not defined", null);
                    error.apply(options.context, [obj]);
                    return;
                }
                if(_.isString(xmlDocument)) {
                    this._xfa.Logger.info("xfa", "xmlDocument is of type string. converting it to document");
                    try {
                        xmlDocument = $.parseXML(xmlDocument);
                    } catch(e) {
                        obj.addMessage(2, "Unable to parse Data XML " + e, null);
                        error.apply(options.context, [obj]);
                        return;
                    }
                }
                if(!(xmlDocument instanceof Document) && !(xmlDocument instanceof Element)) {
                    obj.addMessage(1, "Invalid Argument Error. XML Document is not an instance of Document or Element", null);
                    error.apply(options.context, [obj]);
                    return;
                }
                try {
                    this._xfa.host.playDataXml(xmlDocument);
                } catch(e) {
                    obj.addMessage(2, "Unexpected Exception: Unable to play Data XML " + e, null);
                    error.apply(options.context, [obj]);
                }
                if(success) {
                    success.apply(options.context,[obj]);
                }
            }
        },

        /**
         * Returns Data XML of the Form. If dataXML is passed, it is merged with
         * the Data XML.
         * @returns {string|Node} If dataXML input is String, it returns string, otherwise
         *                        dataXML is updated and returned
         *                        Returns null in case it fails to generate data xml.
         * @param bGenerateXDPRoot whether to generate the xdp root if it doesn't exists
         * @param dataXML {Element|Document|String} If dataXML passed is document or Element, it updates that and
         * returns it. In case of string a new string is returned.
         */
        generateDataXML: function (dataXML, bGenerateXDPRoot) {
            if(_.isUndefined(document.evaluate)) {
                // need to do it here since XPathResult is also undefined in IE
                wgxpath.install();
            }
            try {
                var prefillXML = dataXML || xfalib.runtime.renderContext.data,
                    rootSubform = this._xfa.form._getRootSubform(),
                    bAddXDPRoot = !(bGenerateXDPRoot === false),
                    impl, xmlDoc, xdpElement, datasets, data, rootNode, xPathResult, newXmlDoc;
                if (prefillXML == null) {
                    impl    = document.implementation;
                    xmlDoc  = impl.createDocument ('http://ns.adobe.com/xdp/', 'xdp:xdp', null);
                    datasets = xmlDoc.createElementNS("http://www.xfa.org/schema/xfa-data/1.0/", "xfa:datasets");
                    data = xmlDoc.createElement("xfa:data");
                    rootNode = xmlDoc.createElement(rootSubform.getAttribute("name"));
                    data.appendChild(rootNode);
                    datasets.appendChild(data);
                    xmlDoc.documentElement.appendChild(datasets);
                } else {
                    xmlDoc = prefillXML;
                    if(_.isString(xmlDoc)) {
                        this._xfa.Logger.info("xfa", "xmlDocument is of type string. converting it to document")
                        xmlDoc = $.parseXML(xmlDoc);
                    }
                    rootNode = xfalib.ut.XMLUtils.getXFARootFormElementFromXML(xmlDoc);
                    var xmlDocElement = xmlDoc instanceof Element ? xmlDoc : xmlDoc.documentElement;
                    if (bAddXDPRoot && xmlDocElement.nodeName !== "xdp:xdp") {
                        impl    = document.implementation;
                        xmlDoc  = impl.createDocument ('http://ns.adobe.com/xdp/', 'xdp:xdp', null);
                        datasets = xmlDoc.createElementNS("http://www.xfa.org/schema/xfa-data/1.0/", "xfa:datasets");
                        data = xmlDoc.createElement("xfa:data");
                        rootNode = xmlDoc.importNode(rootNode, true);
                        data.appendChild(rootNode);
                        datasets.appendChild(data);
                        xmlDoc.documentElement.appendChild(datasets);
                    }
                }
                rootSubform.generateDataXML(rootNode, rootNode);
                if(prefillXML == null || _.isString(prefillXML)) {
                    return new XMLSerializer().serializeToString(xmlDoc.documentElement);
                } else {
                    return xmlDoc;
                }
            } catch(e) {
                this._xfa.Logger.error("xfa", "Error in Generating Data XML on Client " + e);
                return null;
            }
        },

        /**
         * Destroy Mobile Form so that another form can be rendered. if bFull parameter
         * is passed as true, then all the scripts are destroyed as well.
         * @param bFull
         */
        destroyForm: function (bFull) {
            $("#mfstyle").remove();
            var oldMap = xfalib.runtime.customPropertyMap;
            // In adaptive form, we never use the view layer of mobile forms, hence adding null check
            if(xfaViewRegistry != null) {
                xfaViewRegistry.rootSubformView = null;
                xfaViewRegistry.clearTemplateCache();
                xfaViewRegistry.resetLayoutManager();
            }
            xfalib.runtime = {
                xfa: null,
                app: null,
                Document: null,
                form: null,
                renderContext: null,
                _private: {},
                customPropertyMap: oldMap
            };
            if(xfalib.runtime.console) {
                xfalib.runtime.console = undefined;
            }
            this._xfa = null;
            xfalib.script.Xfa.Instance = null;
            $(window).trigger("destroy.xfa");
            $(window).off(".xfa");
            xfalib.view.util.TextMetrics._destroy();
            xfalib.view.util.traversalManager._destroy();
            xfalib.view.FieldView.prototype._clearFocusInfo();
            if(bFull === true) {
                $(window).off();
                $("body").empty();
                //this is added by FileAttachment. It should have been
                // a namespace event
                $(document).off("mousedown");
                _.each(xfalib, function (obj, key) {
                   xfalib[key] = undefined;
                });
                xfalib = null;
                wgxpath = undefined;
                FormCalc = undefined;
                // In adaptive form, we never use the view layer of mobile forms, hence adding null check
                if(xfaViewRegistry != null) {
                    xfaViewRegistry.destroy();
                    xfaViewRegistry = undefined;
                }
                $.Widget = undefined;
                $.widget = undefined;
                $.xfaWidget = undefined;
                $.fn = undefined;
                $.prototype.abstractWidget = undefined;
                $.prototype.adobeDateTimePicker = undefined;
                $.prototype.adobeFileAttachment = undefined;
                $.prototype.adobeFileUploader = undefined;
                $.prototype.dateTimeEdit = undefined;
                $.prototype.dropDownList = undefined;
                $.prototype.defaultWidget = undefined;
                $.prototype.fileUpload = undefined;
                $.prototype.imageField = undefined;
                $.prototype.listBox = undefined;
                $.prototype.nwkListBox = undefined;
                $.prototype.numericInput = undefined;
                $.prototype.signatureField = undefined;
                $.prototype.ScribbleImageField = undefined;
                $.prototype.textField = undefined;
                $.prototype.xfaButton = undefined;
                $.prototype.XfaCheckBox = undefined;
                $.expr = undefined;
                window.formBridge = undefined;
                FormBridge = undefined;
                window.renderNextPage = undefined;
                window.handleFooterLogic = undefined;
                window.handleScroll = undefined;
                optionsFromProfileNode = undefined;
                options = undefined;
                FD = undefined;
                window._ = undefined;
                $plugFileWidgetDom = undefined;
            }
        }
    });

    window.formBridge = new FormBridge();
    window.formBridge._$target = $(window.formBridge);
    try {
        var evnt = document.createEvent("CustomEvent");
        evnt.initCustomEvent("FormBridgeInitialized", true, true, {"formBridge": window.formBridge});
        window.dispatchEvent(evnt);
    }

    catch (exception) {
        // written for env rhino to execute(for server side validation)
    }

    if (!window.formBridge.userConfig["postExternalMessageConfig"]) {
        if (window !== window.parent) {
            try {
                window.parent.document.getElementById(window.name);
                //We are here means no cross domain issue. So if user has not defined custom postExternalMessageConfig and
                // then we'll create one which would just send event on parent.
                window.formBridge.registerConfig("postExternalMessageConfig", {
                    "postExternalHandler": function (message) {
                        var tmpEvent = document.createEvent("CustomEvent");
                        tmpEvent.initCustomEvent(message.name, true, true, message.data);
                        window.parent.dispatchEvent(tmpEvent);
                    }
                });
            } catch (e) {
                //ignore the error
            }
        }
    }
    window.formBridge._postExternalMessage({
        name: "FormBridgeInitialized",
        data: {
            "formBridge": window.formBridge
        }
    });
})($);

/**
 * This should house all the internal APIs added tp FormBridge
 * Created by sasdutta on 12/23/2014.
 */

(function ($, _, formBridge) {
    formBridge.internal = {

        /**
         * Get SOM expressions of all the fields in the form, including master page fields
         *
         * @return {Array} of som expressions as strings.
         */
        getAllFieldsSom: function () {
            var fieldsSom = [];
            function getAllFieldsSomVisitor(target) {
                if (target instanceof xfalib.script.Field) {
                    fieldsSom.push(target.somExpression);
                }
            }

            formBridge._xfa.form._getRootSubform()._visitAllmoChildren(getAllFieldsSomVisitor);
            return fieldsSom;
        },

        /**
         * @param pageNum {int} scroll to specified pg no if available
         * @returns nothing
         * @private
         */
        scrollToPage: function (pageNum) {
            if (pageNum > 0 && pageNum <= formBridge.pagingManager().pageCount()) {
                formBridge.pagingManager()._makePage(pageNum);

                var $targetPg = $("#lcforms_xfaform_container .page").eq(pageNum - 1); // zero based index in JQ

                setTimeout(function () {
                    $(window).scrollTop($targetPg.offset().top); // newly added pages need time to render
                });
            }
        },

        resolveNode: function (somExpression) {
            return formBridge._xfa.resolveNode(somExpression);
        },

        pageCount: function () {
            return formBridge.pagingManager().pageCount();
        },

        page: function (fieldNode) {
            return formBridge._xfa.$layout.page(fieldNode);
        },

        normalizeSom: function (som) {
            // adding index and prefix to the som expression as obtained from designer
            if(!_.isString(som)) {
                return null;
            }
            som = som.replace(/\s/g, '');
            var xfaPrefix = "xfa[0].form[0].",
                normalizedSom = (som + ".").replace(/(\])?\./g, function ($0, $1) { return $1 ? $0 : '[0].'; }).slice(0, -1);

            if(normalizedSom.slice(0,xfaPrefix.length) !== xfaPrefix) {
                normalizedSom = xfaPrefix + normalizedSom;
            }
            return normalizedSom;
        }
    };
}($, _, window.formBridge));

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

/**
 * This object hosts FormCalc build-in functions
 */
FormCalc = function(){};


FormCalc.convertArgumentsToArray = function() {
    var args= [];
    for (var i = 0;i<arguments.length;i++) {
        if(arguments[i] instanceof Array) {
            args = args.concat(arguments[i])
        }
        else {
            args.push(arguments[i])
        }
    }
    return args;
}

////Arithmetic Built-in Functions
/**
 * Returns the average of the non-null elements of a given set of numbers.
 */
FormCalc.avg = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
	return FormCalc.runWithNumericArgs(function(){
        var sum = 0 ;
        var valid_count = 0;
        for(var idx=0; idx<arguments.length; idx++ ){
        		sum += arguments[idx];
        		valid_count++;
        }
        return valid_count ? sum/valid_count :null;
	}, args);
};

/**
 * Returns the count of the non-null elements of a given set of numbers.
 */
FormCalc.count = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
    var argus = FormCalc.limitAllNullArgs(args);
	return argus.length ? argus.length : 0
};

/**
 * Returns the max of the non-null elements of a given set of numbers.
 */
FormCalc.max = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
    return FormCalc.runWithNumericArgs(Math.max, args);
};

/**
 * Returns the min of the non-null elements of a given set of numbers.
 */
FormCalc.min = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
    return FormCalc.runWithNumericArgs(Math.min, args);
};

/**
 * Returns the modulus of one number divided by another..
 */
FormCalc.mod = function(a,b){
	if(b==0 ){
		throw "<missing or illegal parameter(s).>";
	}
	return a%b;
};

/**
 * Returns the sum of the non-null elements of a given set of numbers.
 */
FormCalc.sum = function(){
    var args = this.convertArgumentsToArray.apply(this,arguments);
    return FormCalc.runWithNumericArgs(function(){
    	var result = 0;
        for(var idx=0;idx<arguments.length;idx++ ){
        	result += arguments[idx];
        }
        return result;
	}, args);
};

/**
 * Returns a number rounded to a given number of decimal places
 */
FormCalc.round = function(n1,n2){
	if(!FormCalc.isNumeric(n1)){
		return 0;
	}
	if(arguments.length == 1) {
        return Math.round(n1);
    }else if(arguments.length == 2){
    	if(n2==null){
    		return null;
    	}
    	
    	n1 = parseFloat(n1);
    	if(n2 > 12){
    		n2 = 12;
    	}
    	if(isNaN(n1) || !isFinite(n1)){
    		return n1;
    	}else{
    		return n1.toFixed(n2);    		
    	}	
    }
};

/**
 * Returns the radian value of a given number.
 */
FormCalc.deg2Rad = function(angle){
	return FormCalc.isNumeric(angle) ? (angle / 180) * Math.PI :null;
};

/**
 * Returns the degree value of a given number.
 */
FormCalc.rad2Deg = function(radio){
	return FormCalc.isNumeric(radio) ? radio * 180 / Math.PI : null;	
};
////String Built-in Functions 
/**
 * Locates the starting character position of string s2 within string s1.
 */
FormCalc.at = function(n1,n2){
	return n1.indexOf(n2) + 1;
};

/**
 * Returns the string concatenation of a given set of strings.
 */
FormCalc.concat = function(){
	var sArray = new Array();
	for(var i=0;i<arguments.length;i++){
		if(arguments[i]!=null){
			sArray[sArray.length] = arguments[i].toString();
		}
	}

	if(sArray.length == 0){
		return null;
	}else{
		return sArray.join("");
	}
};

/**
 * Extracts a number of characters from a given string, 
 * starting with the first character on the left.
 */
FormCalc.left = function(s,n){
	if(s==null){
		return null;
	}
	return s.substring(0,n);
};

/**
 * Extracts a number of characters from a given string, 
 * beginning with the last character on theright.
 */

FormCalc.right = function(s,n){
	if(s==null){
		return null;
	}
	return s.substring(s.length-n,s.length);
};

/**
 * Returns the number of characters in a given string.
 */
FormCalc.len = function(s){
	if(s==null){
		return 0;
	}else{
		return s.toString().length;		
	}
};

/**
 * Returns a string with all leading white space characters removed.
 */
FormCalc.ltrim = function(s){
	if(s==null){
		return null;
	}
	return s.replace(/^\s+/,"");
};

/**
 * Returns a string with all trailing white space characters removed.
 */
FormCalc.rtrim = function(s){
	if(s == null){
		return null;
	}
	return s.replace(/\s+$/,"");
};

/**
 * Replaces all occurrences of one string with another within a given string.
 */
FormCalc.replace = function(s1, s2, s3) {
	if(s1 == null){
		return null;
	}
	if (undefined == s3) {
		s3 = "";
	}
	return s1.replace(s2, s3);
};

/**
 * returns a string consisting of a given number of blank spaces.
 */
FormCalc.space = function(n){
	var sArray = new Array();
	var num = Math.floor(n);
	for(var i=0;i<num;i++){
		sArray[sArray.length]=" ";
	}
	return sArray.join("");
};

/**
 * Extracts a portion of a given string.
 * 
 */
FormCalc.substr = function(s1,n1,n2){
    if(n2<=0){
    	return "";
    }
    if(n1 < 1){
    	n1 = 1;
    } else if(n1 > s1.length){
    	n1 = s1.length;
    }
	return s1.substring(n1-1,n1-1+n2);
};

/**
 * Inserts a string into another string.
 * 
 */
FormCalc.stuff = function(s1, n1, n2, s2){
    if(n2<0){
    	n2=0;
    }
    if(n1 < 1){
    	n1 = 1;
    } else if(n1 > s1.length){
    	n1 = s1.length;
    }
    if(s2 == undefined){
    	s2="";
    }
	return s1.substring(0, n1-1) + s2 + s1.substring(n1 + n2-1,s1.length);
};

/**
 * Returns a string where all given uppercase characters are converted to lowercase.
 */
FormCalc.lower = function(s1){
	if(s1==null){
		return null;
	}else{
		return s1.toLowerCase();		
	}
};

/**
 * Returns a string with all given lowercase characters converted to uppercase.
 */
FormCalc.upper = function(s1){
	if(s1==null){
		return null;
	}else{
		return s1.toUpperCase();		
	}
};

/**
 * Selects a value from a given set of parameters.
 */
FormCalc.choose = function(n1,s1){
	if(n1 < 1){
		return "";
	}
	if(n1 < arguments.length){
		return arguments[n1];
	} else {
		return "";
	}
};
	
/**
 * Returns true if a value is in a given set.
 */
FormCalc.oneof = function(s1, s2){
	for(var idx = 1; idx < arguments.length; idx++){
		if(s1 == arguments[idx]){
			return true;
		}
	}
	return false;
};

/**
 * This logical function returns true if a value is within a given range.
 */
FormCalc.within = function(s1, s2, s3){
	return (s1>=s2 && s1<=s3);
}

/**
 * 
 */
FormCalc.iffun = function(s1, s2, s3){
	FormCalc.checkMinArgs(arguments.length, 2);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if(s1){
		return s2;
	}else{
		return s3;
	}
};


/**
 * Returns the annual percentage rate for a loan.
 */
FormCalc.apr = function(nPrincipal, nPayment, nPeriods) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if (nPrincipal <= 0 || nPayment <= 0 || nPeriods < 0) {
		throw "<missing or illegal parameter(s).>";
	}
	
	var maxIterations = 500;
	var eps = 0.005;
	var delta = 0.0000001;
	var nInterest = 0.05;
	var nPmtZero = nPrincipal / nPeriods;
	var nPmtCur = FormCalc.loanPmt(nPrincipal, nInterest, nPeriods);
	var i = 1;

	do {
		if (Math.abs(nPmtCur - nPmtZero) < delta)
			break;
		nInterest *= (nPayment - nPmtZero) / (nPmtCur - nPmtZero);
		nPmtCur = FormCalc.loanPmt(nPrincipal, nInterest, nPeriods);
	} while (!(++i > maxIterations || Math.abs(nPayment - nPmtCur) < eps));
	var nRate = (Math.abs(nPmtCur - nPmtZero) < delta) ? 0 : 12 * nInterest;
	return FormCalc.checkResult(nRate);
};

/**
 * Returns the number of periods needed for an investment earning a fixed, but compounded,
 * interest rate to grow to a future value.
 */
FormCalc.cterm = function(nInterest, nFuture, nPresent) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if (nInterest <= 0 || nFuture <= 0 || nPresent < 0) {
		throw "<missing or illegal parameter(s).>";
	}
	var nPeriods = Math.log(nFuture / nPresent) / Math.log(1 + nInterest);
	return FormCalc.checkResult(nPeriods);
};

/**
 * Returns the future value of periodic constant payments at a constant interest rate.
 */
FormCalc.fv = function(nPayment, nInterest, pnPeriods) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	var nPeriods = parseInt(pnPeriods);
	if (nPeriods <= 0 || nPayment <= 0 || nInterest < 0) {
		throw "<missing or illegal parameter(s).>";
	}

	var nVal;
	if (nInterest == 0) {
		nVal = nPayment * nPeriods;
	} else {
		nVal = nPayment * (1 + nInterest)
				* (FormCalc.intRate(nInterest, nPeriods - 1) - 1) / nInterest + nPayment;
	}

	return FormCalc.checkResult(nVal);
};

/**
 * Returns the amount of interest paid on a loan over a period of time.
 *
 */
FormCalc.ipmt = function(nPrincipal, nInterest, nPayment, nStart, nMonths) {
	FormCalc.checkMinArgs(arguments.length, 5);
	FormCalc.checkMaxArgs(arguments.length, 5);
    if(nPrincipal <=0 || nInterest <=0 ||nPayment <=0  ||nStart<1 ||nMonths<1){
    	throw "<missing or illegal parameter(s).>";
    }
	
	nInterest /= 12;
	nStart = parseFloat(nStart);
	nMonths = parseFloat(nMonths);
	if (nPayment <= nPrincipal * nInterest) {
		return 0;
	} else if (nMonths + nStart - 1 > FormCalc.loanTerm(nPrincipal, nInterest, nPayment)) {
		return 0;
	} else {
		var nPrincipalRemaining = nPrincipal;
		var nPrincipalPaidInPeriod = 0;
		var nInterestPaidInPeriod = 0;
		for ( var i = 1; i < nStart; i++) {
			nInterestPaidInPeriod = nPrincipalRemaining * nInterest;
			nPrincipalPaidInPeriod = nPayment - nInterestPaidInPeriod;
			nPrincipalRemaining -= nPrincipalPaidInPeriod;
			if (nPrincipalRemaining <= 0)
				break;
		}
		var nInterestPaid = 0.;
		for ( var i = nStart; i < nStart + nMonths; i++) {
			nInterestPaidInPeriod = nPrincipalRemaining * nInterest;
			nPrincipalPaidInPeriod = nPayment - nInterestPaidInPeriod;
			nPrincipalRemaining -= nPrincipalPaidInPeriod;
			nInterestPaid += nInterestPaidInPeriod;
			if (nPrincipalRemaining <= 0)
				break;
		}
		return FormCalc.checkResult(nInterestPaid);
	}
};

/**
 * Returns the net present value of an investment based on a discount rate, and a series of
 * periodic future cash flows.
 *
 */
FormCalc.npv = function(){
	FormCalc.checkMinArgs(arguments.length, 1);

	var nDiscountRate = FormCalc.parseFloat(arguments[0]);
    if(nDiscountRate<=0){
    	throw "<missing or illegal parameter(s).>";
    }	
	
	var nVal = 0;
	var nDenom = 1;
	for ( var i = 1; i < arguments.length; i++) {
		if(null == arguments[i]){
			return null;
		}
		nDenom *= (1 + nDiscountRate);
		nVal += FormCalc.parseFloat(arguments[i]) / nDenom;
	}
	return FormCalc.checkResult(nVal);

};

/**
 * Returns the payment for a loan based on constant payments and a constant interest rate.
 */
FormCalc.pmt = function(nPrincipal, nInterest, nPeriods) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if(nPrincipal <=0 || nInterest<=0 || nPeriods <=0){
    	throw "<missing or illegal parameter(s).>";
    }
	var nPayment = FormCalc.loanPmt(parseFloat(nPrincipal), parseFloat(nInterest),
			parseInt(nPeriods));
	return FormCalc.checkResult(nPayment);

};

/**
 * Returns the amount of principal paid on a loan over a period of time.
 * 
 */
FormCalc.ppmt = function(nPrincipal, nInterest, nPayment, nStart, nMonths) {
	FormCalc.checkMinArgs(arguments.length, 5);
	FormCalc.checkMaxArgs(arguments.length, 5);
    if(nPrincipal <=0 || nInterest <=0 ||nPayment <=0  ||nStart<1 ||nMonths<1){
    	throw "<missing or illegal parameter(s).>";
    }
	
	nPrincipal = parseFloat(nPrincipal);
	nInterest = parseFloat(nInterest);
	nPayment = parseFloat(nPayment);
	nStart = parseInt(nStart);
	nMonths = parseInt(nMonths);

	nInterest /= 12;
	if (nPayment <= nPrincipal * nInterest) {
		return 0;
	} else if (nMonths + nStart - 1 > FormCalc.loanTerm(nPrincipal, nInterest, nPayment)) {
		return 0;
	} else {
		var nPrincipalRemaining = nPrincipal;
		var nPrincipalPaidInPeriod = 0;
		var nInterestPaidInPeriod = 0;
		for ( var i = 1; i < nStart; i++) {
			nInterestPaidInPeriod = nPrincipalRemaining * nInterest;
			nPrincipalPaidInPeriod = nPayment - nInterestPaidInPeriod;
			nPrincipalRemaining -= nPrincipalPaidInPeriod;
			if (nPrincipalRemaining <= 0)
				break;
		}
		var nPrinciplePaid = 0;
		for ( var i = nStart; i < nStart + nMonths; i++) {
			nInterestPaidInPeriod = nPrincipalRemaining * nInterest;
			nPrincipalPaidInPeriod = nPayment - nInterestPaidInPeriod;
			nPrincipalRemaining -= nPrincipalPaidInPeriod;
			nPrinciplePaid += nPrincipalPaidInPeriod;
			if (nPrincipalRemaining <= 0)
				break;
		}
		return FormCalc.checkResult(nPrinciplePaid);
	}
};

/**
 * Returns the present value of an investment of periodic constant payments at a constant 
 * interest rate.
 *
 */
FormCalc.pv = function(nPayment, nInterest, nPeriods) {
	FormCalc.checkMinArgs(arguments.length, 3);
	FormCalc.checkMaxArgs(arguments.length, 3);
	if (nPayment <= 0 || nPeriods <= 0 ) {
		throw "<missing or illegal parameter(s).>";
	}
	if(nPayment==null || nInterest==null){
		return null;
	}
	var nPayment = parseFloat(nPayment);
	var nInterest = parseFloat(nInterest);
	var nPeriods = parseInt(nPeriods);

	var nVal;
	if (nInterest == 0) {
		nVal = nPayment * nPeriods;
	} else {
		nVal = nPayment * (1 - 1 / FormCalc.intRate(nInterest, nPeriods)) / nInterest;
	}
	return FormCalc.checkResult(nVal);
};

/**
 * Returns the compound interest rate per period required for an investment to grow from
 * present to future value in a given period.
 * 
 */
FormCalc.rate = function(nFuture, nPresent, nPeriods) {
	if (nFuture <= 0. || nPresent <= 0. || nPeriods <= 0) {
		throw "<missing or illegal parameter(s).>";
	}

	var nFuture = parseFloat(nFuture);
	var nPresent = parseFloat(nPresent);
	var nPeriods = parseInt(nPeriods);

	var nRate = Math.exp(Math.log(nFuture / nPresent) / nPeriods) - 1;
	return FormCalc.checkResult(nRate);
};

/*
 * Term This function returns the number of periods needed for an investment
 * earning a fixed, but compounded interest rate to grow to a future value.
 */
FormCalc.term = function(nPayment, nInterest, nFuture) {
	var nPayment = FormCalc.parseFloatOrThrowError(nPayment);
	var nInterest = FormCalc.parseFloatOrThrowError(nInterest);
	var nFuture = FormCalc.parseFloatOrThrowError(nFuture);

	if (nPayment <= 0. || nInterest <= 0. || nFuture <= 0.) {
		throw "<missing or illegal parameter(s).>";
	}
	
	var nPeriods;
	if (nFuture <= nPayment) {
		nPeriods = 1;
	} else {
		nPeriods = Math.log((nFuture - nPayment) / nPayment * nInterest
				+ (1 + nInterest))
				/ Math.log(1 + nInterest);
	}
	return FormCalc.checkResult(nPeriods);
};

FormCalc.loanTerm = function(nPrincipal, nInterest, nPayment) {
	var nRemaining = nPrincipal;
	var nMonths = 0;
	while (nRemaining > 0.0) {
		nRemaining = nRemaining - nPayment + nRemaining * nInterest;
		nMonths++;
	}
	return FormCalc.checkResult(nMonths);
};
/**
 * This function returns a Universally Unique Identifier (UUID).
 */
FormCalc.uuid = function(n1) {
    var S4 = function() {
        return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
    };
    if(n1==1){
        return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
    }else{
    	return (S4()+S4()+S4()+S4()+S4()+S4()+S4()+S4());
    }
};
// Private functions

FormCalc.loanPmt = function(nPrincipal, nInterest, nPeriods) {
	return (nPrincipal * nInterest / ((1 - 1 / FormCalc.intRate(nInterest, nPeriods))));
};

FormCalc.intRate = function(nInterest, nPeriods) {
	return Math.pow((1 + nInterest), nPeriods)
};

FormCalc.parseFloatOrThrowError = function(obj) {
	var num = Number(obj);
	if(isNaN(num)){
		throw "<missing or illegal parameter(s).>";
	}else{
		return num;
	}
};

FormCalc.parseFloat = function(obj) {
	var num = Number(obj);
	if(isNaN(num)){
		return 0;
	}else{
		return num;
	}
};

FormCalc.checkResult = function(result) {
	if (result == Number.POSITIVE_INFINITY || result == Number.NEGATIVE_INFINITY){
	   throw "<arithmetic over/underflow.>";
	}else{
		return result;
	}
};

FormCalc.isNumeric = function(input){
	return input!=null && !isNaN(Number(input));
};

FormCalc.checkMinArgs = function(actual, expected) {
	if(actual < expected){
		throw "<missing or illegal parameter(s).>";
	}
};

FormCalc.checkMaxArgs = function(actual, expected) {
	if(actual > expected){
		throw "<missing or illegal parameter(s).>";
	}
};

FormCalc.limitAllNullArgs = function(arrayArgus) {
	var result = new Array();
	for(var i=0;i<arrayArgus.length;i++){
		if(arrayArgus[i]!=null){
			result.push(arrayArgus[i]);
		}
	}
	return result;
};

FormCalc.runWithoutNullArgs = function(func, arrayArgus) {
	var argus = FormCalc.limitAllNullArgs(arrayArgus);
	return argus.length ? func.apply(null,argus) : null;	
};

FormCalc.runWithNumericArgs = function(func, arrayArgus) {
	var argus = new Array();
	for(var i=0;i<arrayArgus.length;i++){
		if(arrayArgus[i]!=null){
        	var el = parseFloat(arrayArgus[i]);
        	if(!isNaN(el)){
        		argus.push(el);
        	}
		}
	}

	return argus.length ? func.apply(null,argus) : null;	
};

/**
 * This function returns the English text equivalent of a given number.
 * 
 */
FormCalc.WordNum=function(){
	var Ones= new Array("Zero","One","Two","Three","Four","Five",
			"Six","Seven","Eight","Nine");
	var Teens =new Array ("Ten","Eleven","Twelve","Thirteen","Fourteen",
			"Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen");
	var Tens= new Array (
			"Zero",  "Ten",   "Twenty",  "Thirty", "Forty",
			"Fifty", "Sixty", "Seventy", "Eighty", "Ninety", "Hundred" );
	var Thousands = new Array (
			"Thousand", "Million",     "Billion",
			"Trillion", "Quadrillion", "Quintillion" );
	var Cents = new Array("Cent"); 
	var Comma=new Array("");
	var Ands  =new Array ("", "And " /* used by FF99 */ );
	var Dollars=new Array ( "Dollar" );
	var Space = " ";
	var Hyphen = "-";
	var QUINTILLION = 1000000000000000000;
	var n=arguments[0];
	var f=arguments[1];
	if(n === null) {
        return null;
    }
    if(isNaN(n)||!isFinite(n)||n<0){
		return "**************"; 
	}
	
	if (f < 0 || 2 < f) {
		f = 0;
	}
	
	var dollars =   n;
	var cents =    Math.floor(((n -  Math.floor(dollars)+ 0.005) * 100));  
	if (cents >= 100) {
		dollars += 1;
		cents -= 100;
	}
	
	var s= new Array();
	var thousands = 6;
	for (var div = QUINTILLION; div >= 1 ; div/=1000) { 
		var number = Math.floor(dollars / div) ; 
		var hundreds = Math.floor(number/ 100) ;
		var tens = Math.floor((number- hundreds * 100) / 10);
		var ones = Math.floor(number- hundreds * 100 - tens * 10);  
                if(number>=1){
                    dollars -= (div * number ); 
                 }
                
                
		if (hundreds >=1) {
			s.push(Ones[hundreds]);
			s.push(Space);
			s.push(Tens[10]);
			s.push(Space);
			if (tens > 0 || ones > 0)
				s.push(Ands[0]);
		}
		if (tens >=1 ) {
			s.push((tens == 1) ? Teens[ones] : Tens[tens]);
			s.push((ones > 0 && tens != 1) ? Hyphen : Space);
		}
		if (ones >=1 && tens != 1) { 
			if (tens > 0 && ones > 0) {
				// safe since Ones contains true literal constants
				var o = Ones[ones];
				//s+=FormCalc.MylowerCase(o);  
				s.push(o.toLowerCase()); 
			}
			else {
				s.push(Ones[ones]);
			}
			s.push(Space);
		}
		thousands--;
		if (thousands >= 0 && number >= 1) {
			s.push(Thousands[thousands]);
			s.push(Comma[0]);
			s.push(Space);
		}
 
  
	}
	//
	// If less than one then use zero.
	//
	if (n < 1.) {
		s.push(Ones[0]);
		s.push(Space);
	}
	//
	// Factor in format:
	//     0 => "One Hundred Twenty-three"
	//     1 => "One Hundred Twenty-three Dollars"
	//     2 => "One Hundred Twenty-three Dollars And Forty Cents"
	//
	if (f == 1 || f == 2) {
		//
		// Append dollar CalcSymbol.
		//
		s.push(Dollars[0]);
		if ( Math.floor(n) != 1)
			s.push('s');
		//
		// Append cents.
		//
		if (f == 2) {
			s.push(Space);
			s.push(Ands[1]);
			var tens =  Math.floor(cents / 10);
			var ones =  Math.floor(cents - tens * 10);
			if (tens > 0) {
				s.push((tens == 1) ? Teens[ones] : Tens[tens]);
			}
			if (tens != 1) {
				if (tens > 0 && ones > 0) {
					// safe since Ones contains true literal constants
					var o = Ones[ones];
					s.push(Hyphen);
					s.push(o.toLowerCase());
				}
				else if (tens == 0) {
					s.push(Ones[ones]);
				}
			}
			s.push(Space);
			s.push(Cents[0]);
			if (cents != 1.)
				s.push('s');
		}
	}
	if(s[s.length-1] == ' '){
		s.pop();		
	}
	return s.join("");
};

FormCalc._Accessor = function(a) {
    if(a && typeof(a) === "object") {
        if(a.className === "field" || a.className === "exclGroup")
            return a.rawValue;
    }
    return a;
};

FormCalc._ArrayAccessor = function(a) {
    if(typeof(a) == "string") {
        var indexArray = a.lastIndexOf("]")+ 1,
            node = a.substr(0, indexArray),
            propIndex = a.indexOf(".",indexArray),
            prop = propIndex == -1 ? "" : a.substr(propIndex + 1, a.length),
            ctxNode = xfalib.runtime.xfa._contextNode(),
            list = ctxNode.resolveNodes(node),
            retArray = []
        for(var i = 0;i<list.length;i++) {
            var item = list.item(i),
                val = prop.length ? this._Accessor(item[prop]) :this._Accessor(item);
            retArray.push(val);
        }
        if(retArray.length == 1)
            return retArray[0]
        else
            return retArray;
    }
    return a;
};

FormCalc.epoch = new Date(1900,0,1)
FormCalc.epochTime = FormCalc.epoch.getTime()
FormCalc.numMillisInDay = 24*60*60*1000
FormCalc.DateFormats= ["med","short","med","long","full"]

FormCalc.num2date = function(n,fmt,locale) {
    function pad2(num) {
        return (+num)>9 ? num+"" : "0"+num;
    }
    locale = locale || "en_US"
    fmt = fmt || FormCalc.DateFmt(0,locale);
    var epoch = new Date(1900,0,1)
    epoch.setDate(n);
    var inputDate = epoch.getFullYear()+"-"+pad2((epoch.getMonth()+1))+"-"+pad2(epoch.getDate());
    return xfalib.ut.PictureFmt.formatDate(inputDate,fmt,locale);
}

FormCalc.date = function() {
    return Math.ceil((new Date().getTime() - this.epochTime)/this.numMillisInDay)
}

FormCalc.DateFmt = function(symbol,locale) {
    symbol = symbol || 0
    locale = locale || "en_US"
    return xfalib.script.Xfa.Instance._getLocaleSymbols(locale,"datePatterns."+FormCalc.DateFormats[symbol])
};
/*
 * ***********************************************************************
 * ADOBE CONFIDENTIAL
 * __________________
 *
 * Copyright 2015 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 * ***********************************************************************
 */

(function ($) {
    $.uaMatch = function( ua ) {
        ua = ua.toLowerCase();
        var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
            /(webkit)[ \/]([\w.]+)/.exec( ua ) ||
            /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
            /(msie) ([\w.]+)/.exec( ua ) ||
            ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) || [];
        return {
            browser: match[ 1 ] || "",
            version: match[ 2 ] || "0"
        };
    };
    // Not clobbering any existing $.browser
    if ( !$.browser ) {
        var
            matched = $.uaMatch( navigator.userAgent ),
            browser = {};
        if ( matched.browser ) {
            browser[ matched.browser ] = true;
            browser.version = matched.version;
        }
        // Chrome is Webkit, but Webkit is also Safari.
        if ( browser.chrome ) {
            browser.webkit = true;
        } else if ( browser.webkit ) {
            browser.safari = true;
        }
        $.browser = browser;
    }
})($);
/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/


/**
 * @package xfalib.ut.Class
 */
(function(_, xfalib){

    xfalib.ns = xfalib.ns || function (namespaceString) {
        var parts = namespaceString.split('.'),
            parent = window,
            currentPart = '';

        for(var i = 0, length = parts.length; i < length; i++) {
            currentPart = parts[i];
            parent[currentPart] = parent[currentPart] || {};
            parent = parent[currentPart];
        }

        return parent;
    };

    var Class = xfalib.ut.Class = function(options) {
        this.options = _.extend({}, this.options, options);
        if(!this.options.jsonModel)
            this.options.jsonModel = {};
        //For perf reason, we are setting jsonModel as direct property instead of using property descriptor
        this.jsonModel = this.options.jsonModel;
        this.initialize.apply(this, arguments);
    };

    _.extend(Class.prototype, {
        initialize : function(){
        },

        xfaUtil :function(){
          return xfalib.ut.XfaUtil.prototype;
        },

        copyArray : function(src,dst,options) {
            var keepReference = this.getOrElse(options, "keepReference", true);
            if(src instanceof Array)
            {
                for (var i = 0;i<src.length;i++)
                {
                    var obj;
                    if(src[i] instanceof Array)
                    {
                        obj = this._createDestination(dst, i, keepReference, []);
                        this.copyArray(src[i],obj,options);
                    }
                    else if(typeof src[i] == "object")
                    {
                        obj = this._createDestination(dst, i, keepReference, {});
                        this.copyObject(src[i],obj,options);
                    } else {
                        obj = src[i];
                    }
                    dst[i] = obj;
                }
                if(dst.length > src.length){
                    dst.splice(src.length, (dst.length - src.length));  //Remove ths rest of the extra destination items
                }
            }
        },

        /**
         *
         * @param src
         * @param dst
         * @param options e.g. {keepReference: true, exceptions:["htmlId"], transformMaps: {"dataId", function(src, options){ return src "33"+src; }}}
         */
        copyObject : function(src,dst,options) {
            var keepReference = this.getOrElse(options, "keepReference", true);
            var exceptions = this.getOrElse(options, "exceptions", []);
            var transformMaps = this.getOrElse(options, "transformMaps", {});
            if(typeof src == "object") {
                for (var child in src) {
                    if(exceptions.indexOf(child) == -1) {
                        if(src[child] instanceof Array) {
                            dst[child] = this._createDestination(dst, child, keepReference, []);
                            this.copyArray(src[child],dst[child],options);
                        }
                        else if(typeof src[child] == "object" && src[child] != null) {
                            dst[child] = this._createDestination(dst, child, keepReference, {});
                            this.copyObject(src[child],dst[child],options);
                        }
                        else{
                            if(!_.isUndefined(transformMaps[child])){
                                dst[child] = transformMaps[child](src[child], options, src);
                            }
                            else
                                dst[child] = src[child];
                        }
                    }
                }
            }
        },

        _createDestination : function(obj, property, keepReference, defaultValue) {
            if(!keepReference)
                return defaultValue;
            else if(_.isObject(obj) && !obj.hasOwnProperty(property))
                return defaultValue;
            else
                return obj[property] || defaultValue ;  //Would handle both, Array and objects
        },

        /**
         * will replace functions in the object with noop function based on a predicate function's result.
         * If no predicate is passed all functions will be disabled.
         * Warning once disabled object cant be re-enabled.
         *
         * sample predicate to disable all 'public' functions : function (funcName) { return funcName[0] != '_'}
         *
         * @param predicate
         * @private
         */
        _disableFunctions: function (predicate) {
            var noop = function () {},
                disableAll = !_.isFunction(predicate);

            _.each(_.functions(this), function (funcName) {
                if (disableAll || predicate(funcName)) {
                    this[funcName] = noop;
                }
            }, this);
        },

        /**
         * getOrElse can take multiple arguments.
         * arg1(obj): base Object
         * arg2: string representing property chain where properties are concatenated via dot
         * arg3: default value
         **/

        getOrElse : function(obj){
            var currObject = obj;
            if(arguments.length < 2)
                return currObject;
            else if(arguments.length == 2) {
                if(!_.isUndefined(currObject)){
                    return currObject;
                } else {
                    return _.clone(arguments[1]);
                }
            }
            else {
                var propChain = (arguments[1] || "").split(".");
                var defaultValue = arguments[2];
                _.each(propChain, function(prop){
                    if(_.isObject(currObject))
                        currObject = currObject[prop];
                    else
                        currObject = undefined;
                }, this);

                if(!_.isUndefined(currObject))
                    return currObject;
                else {
                    return _.clone(defaultValue) ; //May have to do deep clone in future. TODO: support for conditional clone
                }
            }
        },

        jqId: function (id) {
            return xfalib.ut.XfaUtil.prototype.jqId(id);
        },

        logger : function(){
            return this.xfaUtil().getLogger();
        },

        validateInput : function(param, dataType,fallback){
        	if(typeof param !== "undefined" && param !== null) {
        		switch(dataType) {
        		case "string":
        			param = param+"";
        			break;
        		case "object":
        			if(typeof param !== "object")
        				param = fallback;
        			break;
        	    case "integer":
                    param = parseInt(param);
                    if(isNaN(param))
                        param = fallback;
                    break;
               case "measurement":
                     break;
        		default:
        			if(dataType instanceof Array) {
                        if(!~dataType.indexOf(param))
                            param = fallback
                    }
        		}
        	}
        	return param;
        }

    });

    _.extend(Class, {
        defineProps : function(propsMap){
            _.each(propsMap, function(propDesc, propName){
                //Check property can be resolved using resolveNode
                if(propDesc.resolve) {
                    //Check whether prototype owns the object resolveProperties
                    if(!this.prototype.hasOwnProperty("resolveProperties")) {
                        //check whether prototype inherits the object resolveProperties
                        if(this.prototype.resolveProperties) {
                            //clone the object since we do not want to modify parent's prototype
                            this.prototype.resolveProperties = _.clone(this.prototype.resolveProperties);
                        }
                        else
                            this.prototype.resolveProperties = [];
                    }
                    this.prototype.resolveProperties.push(propName)
                }
                Object.defineProperty(this.prototype, propName, propDesc);

            }, this);
        },
        extend : function(props){
            var child = inherits(this, props);
            child.extend = this.extend;
            return child;
        },
        addMixins : function(mixinBakers){
            if(!_.isArray(mixinBakers)){
                mixinBakers = [mixinBakers];
            }
            _.each(mixinBakers, function(mixinBaker){
                if(mixinBaker.normalProperties){
                    _.extend(this.prototype, mixinBaker.normalProperties);
                }
                if(mixinBaker.propertyDescriptors){
                    this.defineProps(mixinBaker.propertyDescriptors);
                }
            }, this);
        }
    });

    // Shared empty constructor function to aid in prototype-chain creation.
    var ctor = function(){};

    // Helper function to correctly set up the prototype chain, for subclasses.
    // Similar to `goog.inherits`, but uses a hash of prototype properties and
    // class properties to be extended.
    function inherits(parent, protoProps, staticProps) {
        var child;
        var _super = parent.prototype;
        // The constructor function for the new subclass is either defined by you
        // (the "constructor" property in your `extend` definition), or defaulted
        // by us to simply call the parent's constructor.
        if (protoProps && protoProps.hasOwnProperty('constructor')) {
            child = protoProps.constructor;
        } else {
            child = function(){ parent.apply(this, arguments); };
        }

        // Inherit class (static) properties from parent.
        _.extend(child, parent);

        // Set the prototype chain to inherit from `parent`, without calling
        // `parent`'s constructor function.
        ctor.prototype = parent.prototype;
        child.prototype = new ctor();
        child._super = parent.prototype;
        child._superClass = parent;

        // Add prototype properties (instance properties) to the subclass,
        // if supplied.
        if (protoProps) { //_.extend(child.prototype, protoProps);
            // Copy the properties over onto the new prototype
            for (var name in protoProps) {
                if(name == "_defaults"){
                    protoProps[name] = _.extend({}, _super[name], protoProps[name]);
                }
                child.prototype[name] = protoProps[name];
            }
        }


        // Add static properties to the constructor function, if supplied.
        if (staticProps) _.extend(child, staticProps);

        // Correctly set child's `prototype.constructor`.
        child.prototype.constructor = child;

        // Set a convenience property in case the parent's prototype is needed later.
        child.__super__ = parent.prototype;

        return child;
    };
})(_, window.xfalib);
/**
 * Created by vdua on 2/18/2015.
 */
(function (_, xfalib) {
    var XMLUtils = {
        dataSom2xpath: function (dataSom) {
            var xpath = "";

            if (!_.isEmpty(dataSom)) {
                // any dot preceded by ], takes care of dot-s in name,
                // and remove constant prefix "xfa[0].datasets[0].data[0]" and form root name, then join using '/'
                _.each(dataSom.split(/\]\./).slice(4),
                    function (part) {
                        var openBracketPos = part.lastIndexOf('[');
                        xpath += part.substring(0, openBracketPos + 1) +
                            (parseInt(part.substring(openBracketPos + 1)) + 1) + // increment index by 1 for xpath query
                            "]/";
                    });

                if (_.isEmpty(xpath)) {
                    xpath = dataSom;
                } else if (xpath[xpath.length - 1] === '/') {
                    xpath = xpath.slice(0, -1);
                }
            }

            return xpath;
        },

        /**
         * Converts an xPathResult of type iterator to an array
         * @param xPathResult
         * @returns {Array}
         */
        iteratorToArray: function (xPathResult) {
            var result = [];
            // in some browsers, if xpath is invalid xPath result is null whereas some browsers return XpathResult with empty iterator
            var node = xPathResult ? xPathResult.iterateNext() : null;
            while (node != null) {
                result.push(node);
                node = xPathResult.iterateNext();
            }
            return result;
        },
        /**
         * Wrapper API for document.evaluate to provide cross-browser support.
         * @param xpath
         * @param node
         * @param nsResolver
         * @param resultType
         * @param result
         * @returns {Object|*}
         */
        evaluateXPath: function (xpath, node, nsResolver, resultType, result) {
            try {
                if(_.isEmpty(xpath) || !_.isString(xpath) || !(node instanceof Node)) {
                    return null;
                }

                // Determine the appropriate document context for searching.
                var searchContext = node instanceof Document ? node : node.ownerDocument;
                // Check if the document.evaluate function is undefined or if we're in a server-side context.
                var isEvaluateUndefined = typeof searchContext.evaluate === 'undefined';
                var isServerSide = window.guideBridge && window.guideBridge.hostName === "server";
                var needsXPathPolyfill = isEvaluateUndefined || isServerSide;
                if (needsXPathPolyfill) {
                    // Install the wgxpath polyfill to provide evaluate functionality.
                    wgxpath.install(window, true);
                    // Assign the newly installed evaluate function to the search context.
                    searchContext.evaluate = window.document.evaluate;
                }

                var documentToEval = searchContext.evaluate ? searchContext : document;
                xpath = this.sanitizeXPath(xpath);

                return documentToEval.evaluate(xpath, node, nsResolver, resultType, result);

            } catch (exception) {
                xfalib.ut.XfaUtil.prototype.getLogger().error("Could not evaluate xpath: " + xpath  + exception);

            }

        },
         /**
         *Removes all [*] other than ['numeric'] from xpath
         *@param xpath
         *@returns xpath after removing "[*]"
         */
         sanitizeXPath: function(xpath) {
             var xpathArray=xpath.split("/"),
                 resultXpath = _.map(xpathArray, function (path) {
                 return path.replace(/\[(.*\D+.*)\]|\[\]/g,"");
             }).join("/");
             return resultXpath;
         },

        /**
         * Creates all the Elements (if they don't exist) in the xpath leading to the node being searched for in the
         * xpath relative to the element. Optionally creates the node as well if bParentsOnly is false
         * @param xpath
         * @param element
         * @param bParentsOnly whether to create only the parents or the node as well
         * @returns node that is being represented by the xpath relative to the element.
         */
        createElementsFromXPath: function (xpath, element, bParentsOnly) {
            if (xpath != null || element != null) {
                var parts = xpath.split("/"),
                    actualParts = bParentsOnly ? _.initial(parts) : parts,
                    el = element;
                _.each(actualParts, function (part, index) {
                    var som = part.match(/^([^[]+)(\[(\d+)\])?/),
                        childEl;
                    if (som == null) {
                        xfalib.ut.XfaUtil.prototype.getLogger().error("Unsupported expression in Bindref " + part);
                        return null;
                    }
                    //only the last element can be attribute
                    childEl = this.findOrCreateElement(part, el, index === actualParts.length - 1);
                    el = childEl;
                }, this);
                return el;
            }
            return null;
        },

        /**
         * Form an xpath part returns the index as well as the tagName. Index can be * as well
         * @param xpathName
         * @returns {*}
         * @private
         */
        _getElementNameAndIndexFromXPathPart: function (xpathName) {
            var som  =  xpathName.match(/^([^[]+)(?:\[(\d+|\*)\])?/);
            if (som !== null) {
                return {
                    name: som[1],
                    index: som[2] || 0
                };
            }
            return null;
        },

        /**
         * create an element with the tagName elementName for the ownerDocument of element.
         * @param elementName
         * @param element
         * @returns {HTMLElement}
         */
        createElement: function (elementName, element) {
            var el = element.ownerDocument.createElement(elementName);
            return el;
        },

        /**
         * Searches for the nodeXpath relative to element. If it doesn't exists creates it and returns the node
         * @param element
         * @param nodeXpath
         * @param bAttribute if true then check for attribute otherwise not.
         * @returns {Node|*}
         */
        findOrCreateElement: function (nodeXpath, element, bAttribute) {
            try {
                if (element == null) {
                    return null;
                }
                var result = this.evaluateXPath(nodeXpath, element, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null),
                    el = result.iterateNext(),
                    res;
                if (el == null) {
                    res = this._getElementNameAndIndexFromXPathPart(nodeXpath);
                    if (res != null) {
                        if (bAttribute && res.name.match(/^@/)) {
                            var attrName = res.name.replace(/^@/, "");
                            el = element.ownerDocument.createAttribute(attrName);
                            element.setAttributeNode(el);
                        } else {
                            el = element.ownerDocument.createElement(res.name);
                            element.appendChild(el);
                        }
                    }
                }
                return el;

            } catch (exception) {
                xfalib.ut.XfaUtil.prototype.getLogger().error("Following exception "
                    +  "occurred while executing findOrCreateElement " + exception);
            }

        },

        /**
         * Returns the Root Form Elment from the xmlDocumentElement
         * @param xmlDocumentElement It can be a document or Element. If the root element is xdp element, it returns
         *        the grand grand child of that element. otherwise the root element is returned. The root
         *        Element can be either the element itself or documentElement of the element.
         */
        getXFARootFormElementFromXML: function (xmlDocumentElement) {
            if(_.isUndefined(document.evaluate)) {
                wgxpath.install();
            }
            var isElement = xmlDocumentElement instanceof Element,
                docElemName = isElement ? xmlDocumentElement.nodeName : xmlDocumentElement.documentElement.nodeName,
                rootElement = isElement ? xmlDocumentElement : xmlDocumentElement.documentElement,
                nodeList;

            if ("xdp:xdp" === docElemName || "xdp" === docElemName) {
                if (xfalib.ut.XfaUtil.prototype.isIE()) {
                    //IE doesn't support evaluating namespace elements
                    var datasets = rootElement.firstElementChild,
                        data = datasets.firstElementChild;
                    rootElement = data.firstElementChild;
                } else {
                    // assumption is that the xml will be of format <xdp><datasets><data><form1>
                    // TODO: change first * to xfa:datasets
                    nodeList = this.evaluateXPath("*/xfa:data/*", rootElement, formBridge.nsResolver,
                                            XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                    rootElement = nodeList.iterateNext();
                }
            }
            return rootElement;
        },

        /**
         * Returns an object containing the prefix and namespaces present in the rootElement. For default namespace the
         * prefix is "_default"
         * @param rootElement {Element} xml element which has to be looked for namespaces
         * @returns {object} object whose keys are the prefix and values are the namespace
         */
        getNamespaces: function (rootElement) {
            var namespaces = {
                "_default" : null
            };
            _.each(rootElement.attributes, function (attr) {
                var name = attr.name,
                    parsedAttrName = name.match(/^xmlns(?:\:(.*))?/),
                    isNamespace = parsedAttrName != null,
                    namespaceName = isNamespace ? parsedAttrName[1] || "_default" : null;
                if (namespaceName) {
                    namespaces[namespaceName] = attr.value;
                }
            });
            return namespaces;
        },

        /**
         * Returns a namespace resolver given a element. The nsResolver returns the namespace given a prefix by
         * using the namespaces mentioned in the element.
         * @param rootElement element from which to create the nsResolver
         * @returns {function} the function returns the namespace given a prefix.
         */
        getNsResolver: function (rootElement) {
            var namespaces = this.getNamespaces(rootElement),
                nsResolver = (function (namespaces) {
                    return function (nsPrefix) {
                        var namespace = formBridge.nsResolver(nsPrefix) || namespaces[nsPrefix];
                        return namespace;
                    };
                }(namespaces));
            return nsResolver;
        },

        /**
         * Removes default namespaces from xml, basically the namespace defined as xmlns="some namespace". The
         * side-effect of the API is it removes the string "xmlns='some namespace'" from any attribute value as well.
         * @param xml {string}
         * @returns {string}
         */
        removeDefaultNamespace: function (xml) {
            var stringRegex = "(\\s+)" + // any number of spaces
                             "(xmlns=" + // then xmlns=
                            "('[^']*'|\"[^\"]*\"))" + // then value in single quotes ('[^']') or
                                                    //                 double quotes ("[^"]")
                            "(?=[^<>]*>)",  // followed by closing tag (implies attribute) and before another
                                           // opening tag(implies text)
                regex = new RegExp(stringRegex, "g");
            return xml.replace(regex, "$1");
        }
    };
    xfalib.ut.XMLUtils = XMLUtils;
}(_, xfalib));
/**
 * @package xfalib.ut.Logger
 * @import xfalib.ut.Class
 */

(function(_, xfalib, $){
    var categoryAcronyms = {
                            "a": "xfa",
                            "b": "xfaView",
                            "c": "xfaPerf"
        },
        loggerTypes = ["off", "console", "server", "consoleServer"];
    var Logger = xfalib.ut.Logger = xfalib.ut.Class.extend({

//      Count of log messages so far.
        LOG_COUNT : {
            level : {
                "FATAL" : 0,
                "ERROR" : 0,
                "WARN" : 0,
                "INFO" : 0,
                "DEBUG" : 0,
                "TRACE" : 0,
                "ALL" : 0
            },
            category : {
                "xfa" : 0,
                "xfaView" : 0,
                "xfaPerf" : 0,
                "Unknown" : 0
           }
        },

        /**
         * Log level to turn logging off (default).
         * @static
         * @final
         * @type Number
         */
        OFF : 0,

        /**
         * Log level for fatal error messages.
         * @static
         * @final
         * @type Number
         */
        FATAL : 1,

        /**
         * Log level for error messages.
         * @static
         * @type Number
         * @final
         */
        ERROR : 2,

        /**
         * Log level for warning messages.
         * @static
         * @type Number
         * @final
         */
        WARN : 3,

        /**
         * Log level for info messages.
         * @static
         * @type Number
         * @final
         */
        INFO : 4,

        /**
         * Log level for debug messages.
         * @static
         * @type Number
         * @final
         */
        DEBUG : 5,

        /**
         * Log level for trace messages.
         * @static
         * @type Number
         * @final
         */
        TRACE : 6,

        /**
         * Log level for all messages.
         * @static
         * @type Number
         * @final
         */
        ALL : 7,


        logLevelNames : ["OFF", "FATAL", "ERROR", "WARN", "INFO", "DEBUG", "TRACE", "ALL"],

        initialize : function(){
            var str = "",
                that =this;
            Logger._super.initialize.call(this);
            this.logs = {};
            this.logMessages = "";
            this.logServiceProxy = this.options.logServiceProxy;
            this.contextPath = this.options.contextPath;
            this.renderContext =  this.options.renderContext;
            if(this.jsonModel.logConfigString) {
                _.extend(this.jsonModel, this.parse(this.jsonModel.logConfigString));
            }
            _.each(this.jsonModel.category, function(category) {
                that.LOG_COUNT.category[category] = 0;
            })
        },

        /**
         * parses a log config string of the form <0,1,2,3>-<category string><level integer>-<category string><level integer>..
         * and returns an a config object that logger uses. The function is a private and not to be called outside
         * this function
         *
         * category can not contain numbers and only valid characters are a-zA-Z
         * level can be any integer.
         *
         * category string is converted into actual category for the logger by using default categoryAcronyms
         * [a : xfa, b: xfaView, c: xfaPerf} and the categoryAcronyms passed to the options while instantiating the
         * object. If not found in both the acronyms then the value category string is used as actual category
         *
         * For example for the input string 1-a9-b9-c9 return object is
         * {on: true, category: [xfa,xfaView, xfaPerf], level: [9, 9, 9], type: console}
         *
         * For the input string 1-a9-b9-c9-d9-e11 with options.categoryAcronyms {a:a, d:AF} return object is
         * {on: true, category: [xfa,xfaView, xfaPerf, AF, e], level: [9, 9, 9, 9, 11], type: console}
         */
        parse : function(configString) {
            var arr = configString.split("-"),
                logType = _.first(arr),
                logConfig = _.rest(arr),
                res = {
                    on: logType === "0" ? "false": "true",
                    category: [],
                    level:[],
                    type:loggerTypes[parseInt(logType)]
                };
           _.each(logConfig, function(item, index) {
                var config = item.match(/^([A-Za-z]+)(\d+)$/),
                    category;
                if (config && config.length === 3) {
                    category = this.getOrElse(categoryAcronyms, config[1],
                                    this.getOrElse(this.jsonModel, "categoryAcronyms." + config[1], config[1]));
                    res.category.push(category);
                    res.level.push(parseInt(config[2]));
                } else {
                    //calling this because logger is not initialized as of now
                    this.consoleHandler(this.resolveMessage(xfalib.locale.LogMessages["ALC-FRM-901-020"],
                                                    [item, configString]))
                }
            }, this);
            return res;
        },

        /*
         *
         */
        resolveMessage : function(message, snippets) {
            snippets = snippets || [];
            return message.replace(/{(\d+)}/g, function(match, number) {
                return typeof snippets[number] != 'undefined'
                    ? snippets[number]
                    : match
                    ;
            });
        },

        /**
         * Writes a message to the console.
         * @private
         * @param {Number} level The log level
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         * @return The log message
         * @type String
         */
        log : function(category, level, message, snippets) {
            var d= new Date();
            var day = d.getDate();
            var month = d.getMonth() + 1;
            var year = d.getFullYear();
            var mili = d.getMilliseconds();
            var sec = d.getSeconds();
            var min = d.getMinutes();
            var hour = d.getHours();
            var date = day + "." + month + "." + year +" " + hour + ":" + min + ":" + sec + ":" + mili;
            if(this.jsonModel && this.jsonModel.category) {
                for(var i = 0; i<this.jsonModel.category.length; i++) {
                    if (level != 0 && this.jsonModel.level[i] >= level && this.jsonModel.category[i] == category && this.jsonModel.on == "true") {

                        var resolvedMessage = message;
                        if(snippets){
                            //resolve message with snippet
                            resolvedMessage = this.resolveMessage(message, snippets);
                        }

                        var text = "";
                        text += date ;
                        text += " *" + this.logLevelNames[level] + "*";
                        text += " [" +  category + "]" ;
                        text += "  " + resolvedMessage + "\r\n" ;
                        this.logMessages += text ;
                        if(this.jsonModel.type == "console" || this.jsonModel.type == "consoleServer" ) {
                            ++this.LOG_COUNT.category[category || 'Unknown'];
                            ++this.LOG_COUNT.level[this.logLevelNames[parseInt(level) < 8? level:7]];
                            this.consoleHandler(text, level);
                        }
                    }
                }
            }
        },

        consoleHandler : function(text, level){
            if(typeof console != "undefined") {
                var levelName = typeof this.logLevelNames[level] === "string"
                    ? this.logLevelNames[level].toLowerCase()
                    : "log",
                    logFunction = console.log;
                if (typeof console[levelName] === "function") {
                    logFunction = console[levelName]
                }
                logFunction.call(console, "\n\n\n" + text);
                //Error log already shows the call stack for debugging.
                if(levelName !== "error") {
                    try {
                        n.test
                    } catch (exception) {
                        if (exception.stack) {
                            logFunction.call(console, exception.stack.replace("ReferenceError: n is not defined", ""));
                        }
                    }
                }
            }

        },

        /*
         *  Helper function to ger submit service proxy url
         */
        _getLogServiceProxyUrl: function() {
            var logServiceProxyUrl = "";
            if(this.logServiceProxy)
                logServiceProxyUrl += this.logServiceProxy;
            else //finally hard code it
                logServiceProxyUrl += ((this.contextPath && this.contextPath != "/") ? this.contextPath : "") + "/content/xfaforms/profiles/default.log.html";
            return logServiceProxyUrl;
        },

        _invokeAtServer: function(options) {
            var localSubmitUrl =  this._getLogServiceProxyUrl();
            var params = {
                    async: true,
                    url: localSubmitUrl,
                    type: 'POST',
                    contentType: 'application/x-www-form-urlencoded; charset=UTF-8',
                    data: options
                };
            $.ajax(params);
        },

        isServerLoggingEnabled : function(){
            if((this.jsonModel.on == "true") && (this.jsonModel.type == "server" || this.jsonModel.type == "consoleServer"))
                return true;
            else
                return false;
        },

        serverHandler :function() {
            var options = {'logMessages' : this.logMessages, 'renderContext' : this.renderContext};
            this._invokeAtServer(options);
            this.logMessages = "" ;
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #FATAL} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        fatal : function(category, message, snippets) {
            this.log(category, this.FATAL, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #ERROR} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        error : function(category, message, snippets) {
            this.log(category, this.ERROR, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #WARN} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        warn : function(category, message, snippets) {
            this.log(category, this.WARN, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #INFO} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        info : function(category, message, snippets) {
            this.log(category, this.INFO, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #DEBUG} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        debug : function(category, message, snippets) {
            this.log(category, this.DEBUG, message, snippets);
        },

        /**
         * Writes a message to the console if log level is set to
         * {@link #TRACE} or higher.
         * @static
         * @param {String} message The log message
         * @param {String/String[]} snippets (optional) The texts replacing
         *        <code>{n}</code>
         */
        trace :  function(category, message, snippets) {
            this.log(category, this.TRACE, message, snippets);
        },

        isLogEnabled : function(category, level) {
            if(this.jsonModel.on == "true") {
                var pos = this.jsonModel.category.indexOf(category) ;
                if(this.jsonModel.level[pos] >= level)
                    return true;
            }
            return false;
        }

    });
})(_, xfalib, $);
/**
 * @package xfalib.ut.EventClass
 * @import xfalib.ut.Class
 */
(function(_, xfalib){
    // Regular expression used to split event strings
    // Regular expression used to split event strings
    var eventSplitter = /\s+/;

    // A module that can be mixed in to *any object* in order to provide it with
    // custom events. You may bind with `on` or remove with `off` callback functions
    // to an event; trigger`-ing an event fires all callbacks in succession.
    //
    var EventClass = xfalib.ut.EventClass =  xfalib.ut.Class.extend({

        // Bind one or more space separated events, `events`, to a `listener`
        // object. The object should implement `handleEvent` function which will be
        // called on event dispatch
        on: function(event, listener, context) {

            var calls, list,retVal = true;
            var fnCallback = _.isFunction(listener) ? listener : null;
            if (!listener || (!listener["handleEvent"] && !fnCallback)) return false;

            calls = this._callbacks || (this._callbacks = {});

            list = calls[event] || (calls[event] = []);
            if(fnCallback){
                context = context || this;
                var found = _.find(list, function(callback){
                    return (callback.fn == fnCallback && callback.context == context);
                }, this);
                if(found)
                    return false;
                else {
                    list.push({"fn" : fnCallback, "context": context});
                }
            }
            else{
                if(~list.indexOf(listener))
                    return false;
                else
                    list.push(listener);
            }

            return  true;
        },

        // Remove one or many callbacks. If `listener` is null, removes all listener for the
        // event. If `events` is null, removes all bound callbacks for all events.
        off: function(events, listener, context) {
            var event, calls, node;

            // No events, or removing *all* events.
            if (!(calls = this._callbacks)) return;
            if (!(events || listener)) {
                delete this._callbacks;
                return this;
            }

            var fnCallback = _.isFunction(listener) ? listener : null;
            // Loop through the listed events and contexts and remove the required ones.
            events = events ? events.split(eventSplitter) : _.keys(calls);
            while (event = events.shift()) {
                node = calls[event];
                calls[event] = _.filter(calls[event],function(elem) {
                    if(typeof(listener) !== "undefined"){
                        if(fnCallback && elem.fn == fnCallback && elem.context == context)
                            return false;
                        else if(!fnCallback && listener === elem)
                            return false;
                    }
                    else{
                        return false;
                    }
                    return true;
                });
                if(!calls[event].length)
                    delete calls[event];
            }

            return this;
        },

        // Trigger one or many events, firing all bound callbacks. Callbacks are
        // passed the same arguments as `trigger` except the first
        trigger: function(events) {
            var event, calls, rest;
            if (!(calls = this._callbacks)) return this;
            events = events.split(eventSplitter);
            var payLoad = _.rest(arguments);
            while (event = events.shift()) {
                _.each(calls[event],function(callback) {
                    if(callback.fn && callback.context){
                        callback.fn.apply(callback.context, payLoad);
                    }
                    else if (_.isFunction(callback.handleEvent)){
                        callback.handleEvent.apply(callback, payLoad);
                    }
                });
            }

            return this;
        }

    });


})(_, xfalib);


(function (_, $, xfalib) {
    var XfaUtil = xfalib.ut.XfaUtil = function () {
        },
        registeredLocaleProperties = null,
        timeoutListenerAttached = false,
        timeouts = [],
        attachClearTimeoutListener = function (timeout) {
            timeouts.push(timeout);
            if (timeoutListenerAttached === false) {
                $(window).one("destroy.xfa", function () {
                    _.each(timeouts, function (_timeout) {
                        clearTimeout(_timeout);
                    });
                    timeouts = [];
                    timeoutListenerAttached = false;
                });
                timeoutListenerAttached = true;
            }
        };
    _.extend(XfaUtil.prototype, {
        _globalUniqueId: (new Date()).getTime(),
        logger: null,

        formScaleFactor: 1,      // used to appropriately scale the form when contained inside an iframe

        getOrElse: xfalib.ut.Class.prototype.getOrElse,
        //map of event names between XTG and Mobile Form
        //Mobile Form uses different names for some the event and let's fix those names before sending them to XTG.
        _xtgEventName: {
            "$formready": "ready",
            "$layoutready": "ready"
        },

        generateUID: function () {
            return "UID" + (++XfaUtil.prototype._globalUniqueId);
        },

        matchJsonType: function (jsonModel, _class) {   //TODO: handle getOrElse
            return (jsonModel && _class && XfaUtil.prototype.getOrElse(jsonModel._class, "").toLowerCase() == ("" + _class).toLowerCase());
        },

        $data: function (elem, name, data) {
            if (!$.data(elem, "_xfaInitialized")) {
                //Initialized data- attributes parse for once using this call.
                // Next onward don't use this. Instead use $.data which is cheap/
                $(elem).data();
                $.data(elem, "_xfaInitialized", true); //Mark the element to say that data has been initialized.
            }
            return $.data(elem, name, data);
        },

        /*
         * alternative to jQuery.css which sets style properties directly through element.style. This is much faster then
         * corresponding jQuery.css alternative.
         *
         * Warning: this only supports standard css property names and does not do any pre-processing of name and value.
         * So calling this, make sure the style names are compatible.
         */
        $css: function (elem, stylesObj) {
            // Exclude the following css properties to add px. copied from jquery.cssNumber to add hyphenated style names
            var cssNumber = {
                "fillOpacity": true,
                "fill-opacity": true,
                "fontWeight": true,
                "font-weight": true,
                "lineHeight": true,
                "line-height": true,
                "zIndex": true,
                "z-index": true,
                "opacity": true,
                "orphans": true,
                "widows": true,
                "zoom": true
            };

            for (var prop in stylesObj) {
                var value = stylesObj[prop];
                // If a number was passed in, add 'px' to the (except for certain CSS properties)
                if (_.isNumber(value) && !cssNumber[ prop ]) {
                    value += "px";
                }
                elem.style[prop] = value;
            }
        },

        isTableHF: function (iChildNode) {
            //model can be a Node object or simply a json
            var assistJson = _.find(iChildNode.children, function (jChild) {
                return jChild._class == "assist";
            }, this);
            var childRole = (assistJson || {}).role;
            if (childRole == "TH" || childRole == "TF")
                return true;
            else
                return false;
        },

        getUiOneOfChildTag: function (uiParent) {
            var uiEl = _.find(uiParent.children, function (child) {
                return child._class == "ui";
            });
            if (!uiEl)
                return undefined;
            var uiOneOfChildMap = xfalib.runtime.xfa._templateSchema._getOneOfChild("ui");
            var uiOneOfChild = _.find(uiEl.children, function (child) {
                return uiOneOfChildMap[child._class] == true;
            });
            if (!uiOneOfChild)
                return undefined;
            return uiOneOfChild._class;
        },

        //TODO: this should be removed. One of the worst function.
        dIndexOf: function (searchArray, item2Find) {
            var ind = -1;
            _.find(searchArray, function (item, index) {
                return item == item2Find && (ind = index)
            });
            return ind;
        },

        splitStringByWidth: function (value, width, refEl) {
            var i = value.length , expectedWidth;
            do {
                expectedWidth = xfalib.view.util.TextMetrics.measureExtent(value.slice(0, i), {"refEl": refEl, maxWidth: -1}).width;
                i--;
            } while (expectedWidth > width)
            if (i != value.length - 1)
                return value.slice(0, i + 1);
            return value;
        },

        isRepeatabeEl: function (elTag) {
            if (elTag == "subform" || elTag == "subformSet")
                return true;
            else
                return false;
        },

        /**
         * @function
         * stripOrCall(toStrip, diffFunc, fArgs)
         * @description
         * common utility function to handle final submission payload stripping
         * @param {bool} toStrip : flag to signify whether to optimize jsonModelDiff size, by stripping off unnecessary properties
         * @param {function} diffFunc : callback func. call in case submit is not on
         * @param {Array} fArgs : arguments to be passed to the diff func.
         * @returns {object} object containing the jsonDiff
         */
        // should ALWAYS be called with a flag signifying if a submission is in progress,
        // and a callback function to compute the json to be sent back during submission, usually an apt '_computeJsonDiff'
        stripOrCall: function (toStrip, diffFunc, fArgs) {
            if (toStrip) {
                return {
                    "changed": false,
                    "jsonDifference": {}
                };
            }
            else if (_.isFunction(diffFunc)) {
                return diffFunc.apply(this, fArgs);
            }
        },

        /**
         * @function
         * partialStripOrCall(stripLvl, diffFunc, fArgs)
         * @description
         * common utility function to handle final submission payload stripping or for output of getFormState.
         * @param {int} diff_level : flag to signify whether to optimize jsonModelDiff size, by stripping off unnecessary properties
         *                        must be 0,1, or 2, as with "diff_level" param of _computeJsonDiff.
         * @param {function} diffFunc : callback func. call in case submit is not on
         * @returns {object} object containing the jsonDiff
         */
        partialStripOrCall: function (diff_level, diffFunc) {
            var diffObj = diffFunc.call(this, diff_level);

            if (!diffObj.changed) {
                if(diff_level === 1) {
                    diffObj = {
                        "changed": true,
                        "jsonDifference": {
                            "_class": this.jsonModel._class,
                            "name": this.jsonModel.name
                        }
                    };
                } else {
                    diffObj.jsonDifference = {};  // don't need stuff for other cases
                }
            }

            return diffObj;
        },

        /**
         * @function
         * stripObject(obj, exceptionNames)
         * @description
         * Utility function to strip unnecessary properties from an object
         * @param {object} obj : the object to strip
         * @param {Array} exceptionNames : array holding names of important properties to preserve
         * @returns {boolean} : true if this obj, or any of it's descendant is returned un-stripped
         */
        stripObject: function (obj, exceptionNames) {
            if (_.isEmpty(obj) || !_.isObject(obj)) {
                return true;
            } else {
                var dontStrip = false;
                _.each(_.keys(obj), function (propName) {
                    var keepProp = false;
                    if (!_.contains(exceptionNames, propName)) {
                        if (_.isArray(obj[propName])) {
                            _.each(obj[propName], function (arrElem) {
                                var isUnStripped = XfaUtil.prototype.stripObject(arrElem, exceptionNames);
                                keepProp = keepProp || isUnStripped;
                            });
                        } else if (_.isObject(obj[propName])) {
                            keepProp = XfaUtil.prototype.stripObject(obj[propName], exceptionNames);
                        }

                        if (!keepProp) {
                            delete obj[propName];
                        } else {
                            dontStrip = true;
                        }
                    } else {
                        dontStrip = true;
                    }
                });
                return dontStrip;
            }
        },

        computeDomJsonDiff: function (domNode, diff_level) {
            var changed = true;
            if (domNode.hasOwnProperty("_modelChanged")) {
                changed = domNode._modelChanged;
            }
            var jsonDiff = {};
            if (changed) {
                this.copyObject(domNode.jsonModel, jsonDiff, {"exceptions": ["children", "{default}", "extras"]});
            } else {
                jsonDiff = {_class: domNode.className};
            }
            if (!changed && domNode.jsonModel.hasOwnProperty("name")) {
                jsonDiff.name = domNode.jsonModel.name;
            }
            if (domNode.name === "FS_EXTRAS" && diff_level === 3) {
                domNode._childModified = true;
            }
            return {
                "changed": changed,
                jsonDifference: jsonDiff
            };
        },

        getLogger: function () {
            return XfaUtil.prototype.logger || XfaUtil.prototype.getOrElse(xfalib, "runtime.xfa.Logger", null);
        },

        getErrorManager: function () {
            return XfaUtil.prototype.getOrElse(xfalib, "runtime.xfa.ErrorManager", null);
        },

        XFA_CLICK_EVENT: "xfaclick",
        XFA_EXIT_EVENT: "xfaexit",
        XFA_ENTER_EVENT: "xfaenter",
        XFA_CHANGE_EVENT: "xfachange",
        XFA_PREOPEN_EVENT: "xfapreopen",

        btwn: function (val, a, b) {
            return val > a && val < b;
        },

        // function to detect if Browser is chrome / safari (webkit)
        isWebkit: function () {
            return  !!$.browser.webkit || /webkit/.test(navigator.userAgent.toLowerCase()) || !!window.chrome || !!$.browser.chrome || /chrom(e|ium)/.test(navigator.userAgent.toLowerCase()) || !!$.browser.safari || !!window.webkitURL ||
                ( /safari/.test(navigator.userAgent.toLowerCase()) &&
                    /apple computer/.test(navigator.vendor.toLowerCase()) );

            // TODO : find a better way to do this as $.browser is deprecated and
            // userAgent may be spoofed
        },

        clearTimeoutOnDestroy: function (timeout) {
            attachClearTimeoutListener(timeout);
        },

        // function to detect if Browser is  safari
        isSafari: function () {
            return ( /safari/.test(navigator.userAgent.toLowerCase()) &&
                    /apple computer/.test(navigator.vendor.toLowerCase()) );
        },

        getLocaleStrings: function () {
            return xfalib.locale.Strings;
        },

        getLogMessages: function () {
            return xfalib.locale.LogMessages;
        },

        /*
         * This function should not be added in the prototype of any Object
         * as in the case of other functions
         */
        registerLocaleProperties: function (props) {
            registeredLocaleProperties = props;
        },

        /*
         * This function should not be added in the prototype of any Object
         * as in the case of other functions
         */
        getDefaultLocaleProperty: function (property) {
            var localeProps = registeredLocaleProperties || this.getOrElse(xfalib, "script.Xfa._defaultLocale", null);
            return this.getOrElse(localeProps, property, null);
        },

        /**
         * Encodes <script> and </script> with &lt;script&gt; and &lt;/script&gt;
         * Does same with img, video and audio tags also.
         * These tags are being removed since scripts can be run through
         * <img onerror="script" /> (same for audio and video).
         */
        encodeScriptableTags: function (str) {
            var index;
            if (_.isString(str)) {
                return str.replace(/<(\/?)(script[^<>]*)>/gi, '&lt;$1$2&gt;')
                    .replace(/<(\/?)(img[^<>]*)>/gi, '&lt;$1$2&gt;')
                    .replace(/<(\/?)(video[^<>]*)>/gi, '&lt;$1$2&gt;')
                    .replace(/<(\/?)(audio[^<>]*)>/gi, '&lt;$1$2&gt;')
            }
        },

        /**
         *
         * @param id : a string representing an HTML element id.
         *
         * return after applying an escaping '\' before each # . : [ ]
         */
        jqId: function(id) {
            return "#" + id.replace(/(#|:|\.|\[|\])/g, "\\$1");
        },

        _triggerOnBridge: function (eventName, target, property, oldVal, newVal) {
            var evnt = xfalib.script.XfaModelEvent.createEvent(eventName, target,
                property, oldVal, newVal);
            if(formBridge){
                window.formBridge.trigger(eventName, evnt);
            }
        },

        /*
         * pads the passed in String str by pre-pending padChars to convert it to a string of given width.
         * If string length is already greater that equal to given width, original string is returned.
         */
        padString : function (str, width, padChar) {
            padChar = padChar || '0';
            str = str + '';
            return str.length >= width ? str : new Array(width - str.length + 1).join(padChar) + str;
        },

        /**
         * returns true if the browser is IE otherwise false
         * @returns {boolean}
         */
        isIE: function () {
            return $.browser.msie || (navigator.appName === "Netscape" && navigator.userAgent.match(/Trident\//))
        },

        /**
         * returns false if other browser
         * if ie tries to return browser version (non falsy)
         * @returns {*}
         */

        detectIE: function () {
            // 1st try jq
            if($.browser.msie) {
                if($.browser.version && parseInt($.browser.version, 10)) {
                    return parseInt($.browser.version, 10);
                }
            }

            var ua = window.navigator.userAgent;

            // IE 10
            // ua = 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)';

            // IE 11
            // ua = 'Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko';

            // IE 12 / Spartan
            // ua = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0';

            // Edge (IE 12+)
            // ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586';

            var msie = ua.indexOf('MSIE ');
            if (msie > 0) {
                // IE 10 or older => return version number
                return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
            }

            var trident = ua.indexOf('Trident/');
            if (trident > 0) {
                // IE 11 => return version number
                var rv = ua.indexOf('rv:');
                return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
            }

            var edge = ua.indexOf('Edge/');
            if (edge > 0) {
                // Edge (IE 12+) => return version number
                return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
            }

            // other browser
            return false;
        },
        /**
         * returns true if the browser is chrome otherwise false
         * @returns {boolean}
         */
        detectChrome : function () {
            return (!!window.chrome || !!$.browser.chrome || /chrom(e|ium)/.test(navigator.userAgent.toLowerCase()));
        },

        /**
        * @param {String} val: value to be verified
        * @returns {boolean}
        * returns true if the provided string contains DOM element
        */
        isHTML: function(val) {
            //check whether string contains tags, so that $val does not contain result of the val used as selector
            // eg: val = "a" will return result for $(val) which is not required
            if(val && /<[a-z][\s\S]*>/.test(val)) {
                try {
                    var $val = $(val);
                    return $val.length > 0;
                } catch (exception) {
                    // if jquery throws exception that means string is not a proper HTML
                    return false;
                }
            } else {
                return false;
            }
        },

        /**
         * returns true if passed key is non printable, false otherwise.
         * @param {String} key event.key property of a Keyboard event
         */
        isNonPrintableKey : function (key) {
            return (key   // In IE, event.key returns words instead of actual characters for some keys.
               && !_.contains(['MozPrintableKey','Divide','Multiply','Subtract','Add','Enter','Decimal','Spacebar','Del'],key)
               && key.length != 1 )
        },

        /**
        * returns true for ipad
        * @returns {boolean}
        */
        _isIpad : function () {
            return navigator.userAgent.match(/iPad/i) != null;
        },

        /**
        * returns true if the subform is table or having role table else false
        * @param {Object} view
        */
        _tableCheckForAccessibility : function (view) {
            var assist = view.model.getElement("assist", 0, true);
            return this.getOrElse(view, "layoutModel.layout", null) == xfalib.view.LayoutConst.LAYOUT_TABLE
                || this.getOrElse(assist, "role", null) == "Table";
        },

        /**
        * returns value of tooltip to be assigned as title based on values provided in accessibility
        * @param {Object} model
        * @returns toolTipText
        */
        _getToolTipText : function (model) {
            var assist = model.getElement("assist", 0, true),
                toolTipText = "";
            // going against xfa spec, on hover show tooltip or speak text or element name, don't show caption as it's already visible
            // assist priority doesn't matter, but selecting none will disable tooltip on hover
            if (this.getOrElse(assist, "speak.disable", 0) != 1) { // loose compare string value
                toolTipText = this.getOrElse(assist, "toolTip.value", "") ||
                    this.getOrElse(assist, "speak.value", "")   ||
                    this.getOrElse(model, "jsonModel.name", "");
            }
            return toolTipText;
        },

        /**
        * returns value of mandatory message
        * @param {Object} model
        * @returns mandatoryMessage
        */
        _getMandatoryMessage : function (model) {
            var defaultMessage = model._defaults.validate.message.defaultMessage,
                msg = this.getOrElse(model, "validate.message.nullTest", defaultMessage);
            return (msg && msg.value) ? msg.value : defaultMessage.value;
        },
        /**
        * returns boolean based on val1, val2, checkEqual
        * For comparing date, use date object
        */
        _compareVal : function (val1, val2, checkEqual) {
            if(!val1 || !val2) {
                return false;
            }

            if(checkEqual) {
                return val1 >= val2;
            } else {
                return val1 > val2;
            }
        }
    });

    //Special handling for IE.
    if ($.browser.msie || $.browser.mozilla) {
        XfaUtil.prototype.$css = function (elem, stylesObj) {
            $(elem).css(stylesObj);
        }
    }
})(_, $, xfalib);
/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/



(function (_, $, xfalib) {
    xfalib.ut.Utilities = {

        isIE11: function () {
            return !!navigator.userAgent.match(/Trident.*rv\:11\./);
        },

        checkMinMozillaVersion: function (version) {
            return (!this.isIE11() && $.browser.mozilla && parseInt($.browser.version) >= version);
        },

        getObjectFromKeyValueStringList: function (list) {
            var key, value, object = {}, tempArray;
            _.each(list, function (keyValuePair, index) {
                tempArray = keyValuePair.split("=");
                if (tempArray && tempArray.length > 1) {
                    object[tempArray[0]] = tempArray[1];
                }
            });
            return object;
        },

        _getNameWithoutMarker: function (fileName) {
            var markerIndex = fileName.indexOf("__afAttachment__");
            if (markerIndex !== -1) {
                fileName = fileName.substring(markerIndex + "__afAttachment__".length, fileName.length);
            }
            return fileName;
        },

        /*
         * This is to check support of multiple files selection in one add new dialog
         */
        _isDataContainerSupported : function () {
            try {
                var dataContainer = new DataTransfer() || (new ClipboardEvent("")).clipboardData;
                if (dataContainer && dataContainer.items) {
                    return true;
                }
            } catch(err) {
                // if err comes then dataContainer is not supported
            }
            return false;
        }
    };
})(_, $, xfalib);
/**
 * @package xfalib.ut.Scanner
 * @fileOverview helper class to scan over a string.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel:{_str: String}}
 */

(function(_,xfalib){
    var Scanner = xfalib.ut.Scanner = xfalib.ut.Class.extend({

        initialize: function() {
            this._pos = 0;
        },

        isEOF : function(){
            return (this.jsonModel._str.length <= this._pos);
        },

        peek : function(){
            return (this.isEOF()) ? null : this.jsonModel._str.charAt(this._pos);
        },

        optionalConsumeChar : function(aChar){
            if(this.jsonModel._str.charAt(this._pos) == aChar){
                this._pos++;
                return aChar;
            }else{
                return null;
            }
        },

        /**
         * Gets next char ignore quoted string.
         *    |
         *   abc returns c.
         *     |
         *   abc'de'f returns f.
         * @param aChar
         */
        getNCharIQS : function(){
            this._pos++;
            if(this.jsonModel._str.length <= this._pos){
                var current = this.jsonModel._str.charAt(this._pos);
                if(current != '\''){
                    return current;
                }else{
                    if(moveNextExpectedChar('\'')){
                        return this.jsonModel._str.charAt(this._pos);
                    }
                }
            }
            return null;
        },

        moveNextExpectedChar : function(aChar){
            this._pos++;// currently point to '
            while(this._pos< this.jsonModel._str.length && this.jsonModel._str.charAt(this._pos) != aChar){
                this._pos++;
            }
            return this._pos < this.jsonModel._str.length;
        },

        readInteger : function(len){
            if(this.pos+len >this.jsonModel._str.length){
                return null;
            }
            var integer = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._str,this._pos,len);
            this._pos+=len;
            return integer;
        }
    });

    Scanner.lookupNext = function(pat, patPos, filter){
        var patLen = pat.length;
        if(patPos >= patLen){
            return null;
        }

        var token = {};
        token.startPos = patPos;

        var firstChar = pat.charAt(patPos);
        var patValid = false;
        //
        if (firstChar == '\''){
            for (var i = patPos+1; i < patLen;i++ ){
                var chr = pat.charAt(i);
                if(chr =='\''){
                    token.type=1;
                    token.len = i - patPos + 1;
                    patValid = true;
                    break;
                }
            }

        }else if( ('a' <= firstChar && firstChar <= 'z' || 'A' <= firstChar && firstChar <= 'Z') || filter.call(null, firstChar)){
            var endPos = patLen;//end is exclusive
            for (var i = 1; patPos+i < patLen;i++ ){
                if(pat.charAt(patPos+i)!=firstChar){
                    endPos = patPos+i;
                    break;
                }
            }
            token.type=2;
            token.len = endPos - patPos;
            token.patChar = firstChar;
            token.patPos = patPos;
            patValid = true;
        }else{
            if (firstChar == '?' || firstChar == '+' || firstChar == '*') {
                token.type=3;
                token.len = 1;
            }else{
                token.type=4;
                token.len = 1;
            }
            patValid = true;
        }
        if(patValid){
            return token;
        }else{
            throw "Picture is invalid.";
        }
    }
})(_,xfalib);


/**
 * @package xfalib.ut.PictureFmt
 * @fileOverview The file defines methods to parse and format data
 * according to XFA picture patterns.
 * @version 0.0.1
 */
(function(_,xfalib) {

    var PictureFmt = xfalib.ut.PictureFmt = function() {};
    PictureFmt.DatePicturePattern =  /^date(?:\([a-zA-Z]*_[a-zA-Z]*\))?\{([\w\W]*?)\}$/;
    PictureFmt.TimePicturePattern =  /^time(?:\([a-zA-Z]*_[a-zA-Z]*\))?\{([\w\W]*?)\}$/;
    PictureFmt.TextPicturePattern =  /^text\{([\w\W]*?)\}$/;
    PictureFmt.NumPicturePattern =  /^num\{([\w\W]*?)\}$/;

    /**
     * Parses a given data source according to the given picture.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {object}
     */
    PictureFmt.parse  = function(sSource, sPicture,sLocale){
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});

        var match = PictureFmt.DatePicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.parseDate(sSource, match[1]);
        }
        match = PictureFmt.TimePicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.parseTime(sSource, match[1]);
        }
        match = PictureFmt.TextPicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.parseText(sSource, match[1]);
        }
        match = PictureFmt.NumPicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.parseNumeric(sSource, match[1]);
        }
        throw "Invalid picture clause "+sPicture;
    };

    /**
     * Formats a given data source according to the given picture.
     * @param date {object}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.format  = function(sSource, sPicture, sLocale,bRelaxed,bFormatNumberFromasDefaultPC){
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});

        var match = PictureFmt.DatePicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.formatDate(sSource, match[1]);
        }
        match = PictureFmt.TimePicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.formatTime(sSource, match[1]);
        }
        match = PictureFmt.TextPicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.formatText(sSource, match[1],bRelaxed);
        }
        match = PictureFmt.NumPicturePattern.exec(sPicture);
        if(match && match[1]){
            return PictureEngine.formatNumeric(sSource, match[1],sLocale,bRelaxed,bFormatNumberFromasDefaultPC);
        }
            throw "Invalid picture clause "+sPicture;
    };

    /**
     * Checks if a given data source is formatted according to the given picture.
     * @param date {object}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {boolean}
     */
    PictureFmt.formatTest = function (sSource, sPicture, sLocale, bRelaxed, bFormatNumberFromasDefaultPC) {
        var formattedData;
        try {
            formattedData = PictureFmt.format(sSource, sPicture, sLocale, bRelaxed, bFormatNumberFromasDefaultPC);
        }catch(e) {
            return false;
        }

        if(!_.isString(formattedData)) {
            return false;
        } else {
            var parsedData;
            try {
                parsedData = PictureFmt.parse(formattedData, sPicture, sLocale);
            } catch (e) {
                return false;
            }
            if(!_.isString(parsedData) && parsedData !== formattedData) {
                return false;
            }
        }
        return true;
    };

    /**
     * Parses a given data source according to the given date picture
     * under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.parseDate  = function(sSource, sPicture,sLocale){
        var picRegexp = PictureFmt.DatePicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.parseDate(sSource, match[1]);
        }else{
            return PictureEngine.parseDate(sSource, sPicture);
        }
    };


    /**
     * Formats a given data source according to the given date picture
     * * under the given sLocale.
     * @param date {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.formatDate  = function(date, sPicture, sLocale){
        var picRegexp =  PictureFmt.DatePicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.formatDate(date, match[1]);
        }else{
            return PictureEngine.formatDate(date, sPicture);
        }
    };

    /**
     * Parses a given data source according to the given date picture
     * under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {date}
     */
    PictureFmt.parseTime  = function(sSource, sPicture,sLocale){
        var picRegexp = PictureFmt.TimePicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.parseTime(sSource, match[1]);
        }else{
            return PictureEngine.parseTime(sSource, sPicture);
        }
        return null;
    };


    /**
     * Formats a given data source according to the given date picture
     * * under the given sLocale.
     * @param date {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.formatTime  = function(date, sPicture, sLocale){
        var picRegexp =  PictureFmt.TimePicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.formatTime(date, match[1]);
        }else{
            return PictureEngine.formatTime(date, sPicture);
        }
    };

    /**
     * Parses a given data source according to the given text picture
     * under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.parseText  = function(sSource, sPicture,sLocale){
        var picRegexp = PictureFmt.TextPicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.parseText(sSource, match[1]);
        }else{
            return PictureEngine.parseText(sSource, sPicture);
        }
    };

    /**
     * Formats a given data source according to the given text picture
     *  under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.formatText  = function(sSource, sPicture, sLocale,bRelaxed){
        var picRegexp =  PictureFmt.TextPicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.formatText(sSource, match[1],bRelaxed);
        }else{
            return PictureEngine.formatText(sSource, sPicture,bRelaxed);
        }
        return null;
    };

    /**
     * Parses a given data source according to the given numeric picture
     * under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.parseNumeric  = function(sSource, sPicture,sLocale){
        var picRegexp = PictureFmt.NumPicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.parseNumeric(sSource, match[1]);
        }else{
            return PictureEngine.parseNumeric(sSource, sPicture);
        }
        return null;
    };

    /**
     * Formats a given data source according to the given numeric picture
     *  under the given sLocale.
     * @param sSource {string}
     * @param sPicture {string}
     * @param sLocale {string}
     * @returns {string}
     */
    PictureFmt.formatNumeric  = function(sSource, sPicture, sLocale){
        var picRegexp =  PictureFmt.NumPicturePattern;
        var match = picRegexp.exec(sPicture);
        var PictureEngine = new xfalib.ut.PictureEngine({jsonModel:{locale:sLocale}});
        if(match && match[1]){
            return PictureEngine.formatNumeric(sSource, match[1]);
        }else{
            return PictureEngine.formatNumeric(sSource, sPicture);
        }
    };




    /**
     * Parses a given data source according to the given datetime picture
     * under the given sLocale.
     * @param sSource {string}
     *            the source data.
     * @param sPicture {string}
     *            the datetime picture.
     * @param sDateMask {string}
     *            the date sub-picture.
     * @param sTimeMask {string}
     *            the time sub-picture.
     * @param sLocale
     *            the locale name.
     *
     */
    PictureFmt.parseDateTime  = function(sSource, sPicture, sDateMask, sTimeMask, sLocale){

    };
    /**
     * Formats a given data source according to the given datetime picture
     * under the given locale.
     *
     * @param sSource {string}
     *            the source data.
     * @param sPicture {string}
     *            the datetime picture.
     * @param sDateMask {string}
     *            the date sub-picture.
     * @param sTimeMask {string}
     *            the time sub-picture.
     * @param sLocale {string}
     *            the locale name.
     */
    PictureFmt.formatDateTime  = function(sSource, sPicture, sDateMask, sTimeMask, sLocale){

    };

})(_,xfalib);
/**
 * @package xfalib.ut.PictureUtils
 * @fileOverview The file defines static utilities methods.
 * @version 0.0.1
 */

(function(_,xfalib){
    var PictureUtils = xfalib.ut.PictureUtils = function() {}

    PictureUtils.padding = function(number, digits, isFw, zero){
        var leading = ["0","00","000","0000"];
        var numStr = leading[digits-1] + number;
        return numStr.slice(- digits);
    };

    PictureUtils.parseIntAggressive = function(dateString, startPos,len){
        var result = new Object();
        var parsedNum = 0; //The number value parsed from dateString
        var parsedLen = -1; //How many chars parsed according to this pattern;
        for(var idx=0; idx<len && (startPos + idx) < dateString.length; idx++){
            var chr = dateString.charAt(startPos + idx);
            if(chr >='0' && chr <='9'){
                parsedNum = parsedNum *10 + (chr- '0');
            }else{
                parsedLen = idx;
                break;
            }
        }
        if(parsedLen == -1) {
            parsedLen = len;
        }
        result.value = parsedNum;
        result.len = parsedLen;
        return result;
    };

    PictureUtils.parseIntExact = function(dateString, startPos,len){
        var result = 0;
        PictureUtils.assert(startPos+ len <= dateString.length, "mismatch");
        for(var idx=0; idx<len ; idx++){
            var chr = dateString.charAt(startPos + idx);
            if(chr >='0' && chr <='9'){
                result = result *10 + (chr- '0');
            }else{
                throw "unexpected currentChar in PictureUtils.parseInt";
            }
        }
        return result;
    };

    PictureUtils.isDigit = function(chr){
        return /[0-9]/.test(chr) ;
    };

    PictureUtils.inString = function(chr,aString){
        return (aString.indexOf(chr) >=0) ;
    };


    var regExpIsLetter = /[\u0041-\u005a\u0061-\u007a\u00aa-\u00aa\u00b5-\u00b5\u00ba-\u00ba\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u0236\u0250-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ee-\u02ee\u037a-\u037a\u0386-\u0386\u0388-\u038a\u038c-\u038c\u038e-\u03a1\u03a3-\u03ce\u03d0-\u03f5\u03f7-\u03fb\u0400-\u0481\u048a-\u04ce\u04d0-\u04f5\u04f8-\u04f9\u0500-\u050f\u0531-\u0556\u0559-\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0621-\u063a\u0640-\u064a\u066e-\u066f\u0671-\u06d3\u06d5-\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u06fc\u06ff-\u06ff\u0710-\u0710\u0712-\u072f\u074d-\u074f\u0780-\u07a5\u07b1-\u07b1\u0904-\u0939\u093d-\u093d\u0950-\u0950\u0958-\u0961\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2-\u09b2\u09b6-\u09b9\u09bd-\u09bd\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e-\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd-\u0abd\u0ad0-\u0ad0\u0ae0-\u0ae1\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d-\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71-\u0b71\u0b83-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c-\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb5\u0bb7-\u0bb9\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c60-\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd-\u0cbd\u0cde-\u0cde\u0ce0-\u0ce1\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d28\u0d2a-\u0d39\u0d60-\u0d61\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd-\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32-\u0e33\u0e40-\u0e46\u0e81-\u0e82\u0e84-\u0e84\u0e87-\u0e88\u0e8a-\u0e8a\u0e8d-\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5-\u0ea5\u0ea7-\u0ea7\u0eaa-\u0eab\u0ead-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ebd\u0ec0-\u0ec4\u0ec6-\u0ec6\u0edc-\u0edd\u0f00-\u0f00\u0f40-\u0f47\u0f49-\u0f6a\u0f88-\u0f8b\u1000-\u1021\u1023-\u1027\u1029-\u102a\u1050-\u1055\u10a0-\u10c5\u10d0-\u10f8\u1100-\u1159\u115f-\u11a2\u11a8-\u11f9\u1200-\u1206\u1208-\u1246\u1248-\u1248\u124a-\u124d\u1250-\u1256\u1258-\u1258\u125a-\u125d\u1260-\u1286\u1288-\u1288\u128a-\u128d\u1290-\u12ae\u12b0-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0-\u12c0\u12c2-\u12c5\u12c8-\u12ce\u12d0-\u12d6\u12d8-\u12ee\u12f0-\u130e\u1310-\u1310\u1312-\u1315\u1318-\u131e\u1320-\u1346\u1348-\u135a\u13a0-\u13f4\u1401-\u166c\u166f-\u1676\u1681-\u169a\u16a0-\u16ea\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7-\u17d7\u17dc-\u17dc\u1820-\u1877\u1880-\u18a8\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1d00-\u1d6b\u1e00-\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59-\u1f59\u1f5b-\u1f5b\u1f5d-\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe-\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071-\u2071\u207f-\u207f\u2102-\u2102\u2107-\u2107\u210a-\u2113\u2115-\u2115\u2119-\u211d\u2124-\u2124\u2126-\u2126\u2128-\u2128\u212a-\u212d\u212f-\u2131\u2133-\u2139\u213d-\u213f\u2145-\u2149\u3005-\u3006\u3031-\u3035\u303b-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312c\u3131-\u318e\u31a0-\u31b7\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fa5\ua000-\ua48c\uac00-\ud7a3\uf900-\ufa2d\ufa30-\ufa6a\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e-\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]/

    /**
     * TODO Implement method equivalent to Character.isLetter.
     */
    PictureUtils.isLetter = function(chr){
        return regExpIsLetter.test(chr);
    };

    PictureUtils.isLetterOrDigit = function(chr){
        return this.isLetter(chr) || this.isDigit(chr);
    };

    /**
     * Scan this string for the first character in the given set. Similar to
     * strcspn().
     *
     * @param src{String}
     *            the string to scan
     * @param sSkip{String}
     *            the characters to scan for
     * @param nOffset{number}
     *            the position where to start the scan. Default = 0.
     * @return The position, relative to nOffset, for the first character found
     *         in the given set
     */
    PictureUtils.skipUntil = function(srcStr, sSkip, nOffset) {
        var nCharsSkipped = nOffset;

        // starting at the offset position, scan the characters in this string
        // until it matches one of the characters in the given set.
        while (nCharsSkipped < srcStr.length) {
            var i = nCharsSkipped;
            if (sSkip.indexOf(srcStr.charAt(i++)) >= 0)
                break;
            nCharsSkipped = i;
        }

        return nCharsSkipped - nOffset;
    };

    PictureUtils.matchString = function(str, startPos, target){
        if(startPos + target.length > str.length){
            return false;
        }else{
            for(var idx = 0; idx<target.length; idx++){
                if(target.charAt(idx) != str.charAt(startPos + idx)) return false;
            }
            return true;
        }
    };

    PictureUtils.assert = function(condition, message){
        if(!condition){
            throw message;
        }
    };

    PictureUtils.getLocaleObject = function(locale,property) {
        if(locale !== null && xfalib.runtime.xfa) {
            return xfalib.runtime.xfa._getLocaleSymbols(locale, property);
        } else {
            return xfalib.ut.XfaUtil.prototype.getDefaultLocaleProperty(property)
        }
    }

    PictureUtils.getHashOfLocaleObject = function(locale,property) {
          if(!PictureUtils.getHashOfLocaleObject[locale+"_"+property]) {
              var hashObj = {};
              _.each(PictureUtils.getLocaleObject(locale,property), function(val) {
                  var sVal = (val+"").toLowerCase();
                  var hash = 0;
                  for(var i =0;i<sVal.length;i++) {
                      hash+=(i+1)*sVal.charCodeAt(i)
                  }
                  hashObj[hash] = hashObj[hash] || [];
                  hashObj[hash].push(sVal);
              })
              PictureUtils.getHashOfLocaleObject[locale+"_"+property] = hashObj;
          }
          return PictureUtils.getHashOfLocaleObject[locale+"_"+property]
    }

    PictureUtils.convertNumberToLocale = function(locale,number) {
        var zero = PictureUtils.getLocaleObject(locale,"numberSymbols.zero");
        var zeroCode = zero.charCodeAt(0);
        number += "";
        var newNumber = [];
        for(var i = 0;i < number.length;i++) {
            newNumber.push(String.fromCharCode(zeroCode + parseInt(number.charAt(i))));
        }
        return newNumber.join("");
    }

    PictureUtils.parsePictureClause = function (clause){
        if(clause === null || clause === undefined) {
            return [];
        }
        var insidePattern = false,
            insideQuote=false,
            insideLocale = false,
            locale = "",
            type = "",
            pattern = "",
            flag = false,
            currentChar = "",
            result = [],
            matchType = /^num$|^text$|^date$/,
            matchLocale = /^[a-zA-Z]*_[a-zA-Z]*$/,
            i = 0,
            bracketOpenCount = 0;
        for(;i<clause.length;i++) {
            currentChar = clause.charAt(i);
            if(insideQuote && currentChar !== "'") {
                pattern += currentChar;
                continue;
            }
            switch(currentChar) {
               case "'":
                   if(!insidePattern) {
                       // ' is not allowed except insidePattern
                       return null;
                   }
                   insideQuote = !insideQuote;
                   pattern += currentChar;
                   break;
               case "{":
                    if(insidePattern || insideLocale || type === "") {
                        // { is not allowed insidePattern or insideLocale
                        return null;
                    }
                   insidePattern = true;
                    break;
                case "}":
                    if(!insidePattern || (insideLocale && pattern === "") || type === "") {
                        // { is allowed only insidePattern and not insideLocale
                        return null;
                    } else {
                        bracketOpenCount = 0;
                        insidePattern = false;
                        if(matchType.exec(type) === null) {
                            return null;
                        }
                        if(locale !== "" && matchLocale.exec(locale) === null) {
                            return null;
                        }
                        result.push({
                            category: type,
                            mask: pattern,
                            locale: locale
                        })
                    }
                    break;
                case "|":
                    if(type === "" || insidePattern || insideLocale) {
                        return null;
                    } else {
                        type = pattern = locale = "";
                        insidePattern = insideLocale = false;
                    }
                    break;
                case "(" :
                    if(type === "" || bracketOpenCount === 1) {
                        // ( is not allowed inside Locale
                        return null;
                    } else {
                        if(!insidePattern) {
                            insideLocale = true;
                        } else {
                            pattern += currentChar;
                        }
                        bracketOpenCount++;
                    }
                    break;
                case ")" :
                    if((!insideLocale && !insidePattern) || bracketOpenCount === 0) {
                        return null;
                    } else {
                        if(insidePattern) {
                            pattern += currentChar;
                        }
                        insideLocale = false;
                        bracketOpenCount--;
                    }
                    break;
                default:
                    if(insidePattern) {
                        pattern += currentChar;
                    } else if(insideLocale) {
                        locale += currentChar;
                    } else if(type !== "" && (pattern !== "" || locale !== "")){
                        return null;
                    } else {
                        type += currentChar;
                    }
                    break;
           }
       }
       if(insidePattern || insideLocale || insideQuote || bracketOpenCount !== 0) {
           return null;
       }
       return result;
    }

})(_,xfalib);

/**
 * @package xfalib.ut.VisitorBase
 * @import xfalib.ut.Class
 * @fileOverview Base class for visitor
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String}}
 */

(function(_,xfalib) {
    var VisitorBase = xfalib.ut.VisitorBase = xfalib.ut.Class.extend({
        consume : function(token){
            switch (token.type)
            {
                case 1:
                    this.consumeStringLiteral(token);
                    break;
                case 2:
                    this.consumeSubPattern(token);
                    break;
                case 3:
                    this.consumeStringWildCard(token);
                    break;
                case 4:
                    this.consumeCharLiteral(token);
                    break;
            }
        },
        acceptPatternChar : function(chr){
            return false;
        },
        getPicture : function(){
            return this.jsonModel._sPicture;
        },
        abstractMethod : function(){
            throw "Not implemented";
        },
        consumeStringWildCard : this.abstractMethod,
        consumeStringLiteral: this.abstractMethod,
        consumeCharLiteral: this.abstractMethod,
        consumeSubPattern: this.abstractMethod,
        getResult: this.abstractMethod
    });
})(_,xfalib);

/**
 * @package xfalib.ut.NumPictureDesc
 * @import xfalib.ut.Class
 * @fileOverview Pre-process Numeric Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String}}
 */

(function(_,xfalib){
    var NumPictureDesc = xfalib.ut.NumPictureDesc = xfalib.ut.Class.extend({

        initialize: function() {
            this.hasRadix = false;
            this.hasExpon = false;
            this.hasSign = false;
            this.hasPercent = false;
            this.fracDigit = 0;
            this.intDigit = 0;

            this._mbLeftParenSeen = false;
            this._mbRightParenSeen = false;
            this._compactPattern();
            this._xlatePattern();
            NumPictureDesc._super.initialize.call(this);
        },
        
        getPicture : function(){
            return this.jsonModel._sPicture;
        },

        _match2Char : function (char1, char2, idx){
            if(idx+1 < this.jsonModel._sPicture.length){
                return (this.jsonModel._sPicture.charAt(idx) ==char1 && this.jsonModel._sPicture.charAt(idx+1) ==char2);
            }else{
                return false;
            }
        },

        _xlatePattern : function(){
            var patPos = 0;
            for(var token = xfalib.ut.Scanner.lookupNext(this.jsonModel._sPicture, patPos, this._acceptPatternChar); token != null;  ){
                this._consume(token);
                patPos = patPos + token.len;
                token = xfalib.ut.Scanner.lookupNext(this.jsonModel._sPicture, patPos, this._acceptPatternChar);
            }
        },
        
        _compactPattern : function(){
            var buf = new Array();
            for(var index =0, len = this.jsonModel._sPicture.length; index <len; index++){
                if(this._match2Char('D','B',index)){
                    buf.push('D');
                    index++;
                }else if(this._match2Char('d','b',index)){
                    buf.push('d');
                    index++;
                }else if(this._match2Char('C','R',index)){
                    buf.push('C');
                    index++;
                }else if(this._match2Char('c','r',index)){
                    buf.push('c');
                    index++;
                }else{
                    buf.push(this.jsonModel._sPicture.charAt(index));
                }
            }
            this.jsonModel._sPicture = buf.join("");
        },

        _acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "(%$,.)89BCDERSVZbcdrsvzt");
        },

        _consume : function(token){
            if(token.type == 2){
                this._subConsume(token.patChar, token.len);
            }// else not a pattern
        },

        _subConsume : function(chr, chrCnt){
            switch (chr) {
                case'E' :
                    if (chrCnt > 1 || this.hasExpon || (this.fracDigit + this.intDigit)==0)
                        throw "Illegal Numeric Picture: more than one Expon";
                    this.hasExpon = true;
                    break;
                case '(':
                    if (chrCnt > 1 || this._mbLeftParenSeen	|| this.fracDigit + this.intDigit >0 )
                        throw "Illegal Numeric Picture:  ()";
                    this._mbLeftParenSeen = true;
                    break;

                case ')':
                    if (chrCnt > 1 || ! this._mbLeftParenSeen || this._mbRightParenSeen)
                        throw "Illegal Numeric Picture:  ()";
                    this._mbRightParenSeen = true;
                    if(this.fracDigit + this.intDigit >0) this.hasSign = true;
                    break;
                case 'S':
                case 's':
                case 'C': //CR
                case 'c': //cr
                case 'D': //DB
                case 'd': //db
                    this.hasSign = true;
                    break;
                case '%' :
                    this.hasPercent = true;
                    break;
                case '.':
                case 'V':
                case 'v':
                    if (chrCnt > 1 || this.hasRadix)
                        throw "Illegal Numeric Picture: too many vV.";
                    this.hasRadix = true;
                    this._mbFracStartSeen = true;
                    break;
                case '8' :
                case '9' :
                case 'Z':
                case 'z':
                    if (this.hasRadix){
                        this.fracDigit += chrCnt;
                    } else{
                        this.intDigit += chrCnt;
                    }
                    break;
            }
        },

        parseNumberInfo : function(msText){
            var text=msText,
                num = Number(text),
                negative = false
            if(num < 0){
                negative = true;
                num = -num;
                text = text.replace("-","");
            }
            if(this.hasPercent){
                num *= 100;
                text = ""+num;
            }
            var shift = 0;
            if(this.hasExpon){
                var threshold = Math.pow(10,this.intDigit);
                if(num < threshold){
                    while(num*10 < threshold) {
                        num *= 10;
                        shift--;
                    }
                }else{
                    while(num > threshold){
                        num /= 10;
                        shift++;
                    }
                }
                text = num+"";
            }
            var radixPos = text.indexOf(".", 0),
                fractionDigit = radixPos<0 ? 0 : text.length - radixPos - 1

            if(this.fracDigit < fractionDigit) {
                num = num.toFixed(this.fracDigit);
                text = num +""
            }

            if(text.indexOf("0") == 0 && msText.indexOf("0") != 0) {
                text = text.substring(1);
            }

            radixPos = text.indexOf(".", 0)
            var integerDigit = radixPos < 0 ? text.length : radixPos,
                offset = this.intDigit - integerDigit

            if(offset <0 ){
                throw "Exit: most significant " + offset +" digit lost";
            }
            return {
                "integerDigit" : integerDigit,
                "radixPos" : radixPos ,
                "fractionDigit" :  radixPos<0 ? 0 : text.length - radixPos - 1,
                "msText" : text,
                "shift" : shift,
                "isNegative" : negative,
                "padding" :offset
            };
        }
    });

    NumPictureDesc.gsDB = "DB";
    NumPictureDesc.gsCR = "CR";
    NumPictureDesc.gsE = "E";
    NumPictureDesc.gsDSP = "  ";
    NumPictureDesc.gsSSP = " ";

})(_,xfalib);











    /**
 * @package xfalib.ut.TimeInfo
 * @import xfalib.ut.Class
 * @fileOverview A wrapper class for date related information.
 * @version 0.0.1
 */

/**
 * @constructor
 */
(function(_,xfalib){
    var TimeInfo = xfalib.ut.TimeInfo = xfalib.ut.Class.extend({

        initialize: function() {
            this.mHourOfMeriDiem = -1;
            this.mHourOfDay = -1;
            this.mMinuteOfHour = -1;
            this.mSecondOfMinute = -1;
            this.mThousandthOfSecond = -1;
        },

        getISOTime : function(){
            var timeStr = "";
            if(this.mThousandthOfSecond>0){
                timeStr = "-" + this.formatNum(this.mThousandthOfSecond,3);
            }
            if(this.mSecondOfMinute>0 || timeStr!=""){
                timeStr = this.formatNum(this.mSecondOfMinute,2)+timeStr;
                timeStr = ":"+timeStr;
            }
            if(this.mMinuteOfHour>0 || timeStr!=""){
                timeStr = this.formatNum(this.mMinuteOfHour,2)+timeStr;
                timeStr = ":"+timeStr;
            }
            timeStr = this.formatNum(this.mHourOfDay,2) + timeStr;

            return timeStr;
        },

        formatNum : function(num, digits){
            if(num<0){
                num = 0;
            }
            return xfalib.ut.PictureUtils.padding(num, digits);
        },

        getDate : function(){
            var date = new Date();
            this.setTime(date);
            return date;
        },

        setTime : function(date){
            date.setHours(this.mHourOfDay);
            date.setMinutes(this.mMinuteOfHour);
            date.setSeconds(this.mSecondOfMinute);
            date.setMilliseconds(this.mThousandthOfSecond);
        }
    });

    /**
     *
     * <p>Valid ISO8601/XFA time strings are in any one
     * of the following time patterns:
     * <ul>
     * <li> HH[MM[SS[.FFF][z]]]
     * <li> HH[MM[SS[.FFF][+HH[MM]]]]
     * <li> HH[MM[SS[.FFF][-HH[MM]]]]
     * <li> HH[:MM[:SS[.FFF][z]]]
     * <li> HH[:MM[:SS[.FFF][+HH[:MM]]]]
     * <li> HH[:MM[:SS[.FFF][-HH[:MM]]]]
     * </ul>
     */
    TimeInfo.Parse = function(isoDateStr, locale){
        var scanner = new xfalib.ut.Scanner({jsonModel:{_str:isoDateStr}});
        var hours = scanner.readInteger(2);
        var minitues = -1;
        if(!scanner.isEOF()){
            scanner.optionalConsumeChar(':');
            minitues = scanner.readInteger(2);
        }
        var seconds = -1;
        if(!scanner.isEOF()){
            scanner.optionalConsumeChar(':');
            seconds = scanner.readInteger(2);
        }
        var milliseconds = -1;
        if(!scanner.isEOF()){
            scanner.optionalConsumeChar('-');
            milliseconds = scanner.readInteger(3);
        }
        //TODO timezone
        var info = new xfalib.ut.TimeInfo();
       TimeInfo.setPropertyIfNotNull(info,hours,"mHourOfDay");
       TimeInfo.setPropertyIfNotNull(info,minitues,"mMinuteOfHour");
       TimeInfo.setPropertyIfNotNull(info,seconds,"mSecondOfMinute");
       TimeInfo.setPropertyIfNotNull(info,milliseconds,"mThousandthOfSecond");
        return info;
    };

    /**
     *
     * static method
     */
    TimeInfo.setPropertyIfNotNull = function(object, value, proName){
        if(value!=null){
            var d = Number(value);
            if(!isNaN(d)){
                object[proName] = d;
            }
        }
    };

})(_,xfalib);
/**
 * @package xfalib.ut.DateInfo
 * @import xfalib.ut.Class
 * @fileOverview A wrapper class for date related information.
 * @version 0.0.1
 */

/**
 * @constructor
 */

(function(_,xfalib) {
    var DateInfo = xfalib.ut.DateInfo = xfalib.ut.Class.extend({

        initialize: function(options) {
            if (options && !options.isParsingCall ) { // skip setting internal values when called while parsing date formats
                this.date = new Date();
                this._year = this.date.getFullYear();
                this._month = this.date.getMonth() + 1;
                this._day = this.date.getDay();
            }
            DateInfo._super.initialize.call(this);
        },

        formatNum : function(num, digits){
            if(num<0)
                num = 0;
            return xfalib.ut.PictureUtils.padding(num, digits);
        },

        getDate : function(){
            return this.date;
        },
        setDate : function() {
          this.date = new Date(this._year,this._month-1,this._day)
        },
        getISODate : function(){
            var isoDate = [];

            isoDate.push(this.formatNum(this._year, 4));
            isoDate.push("-");
            isoDate.push(this.formatNum(this._month, 2));
            isoDate.push("-");
            isoDate.push(this.formatNum(this._day, 2));

            return isoDate.join("");
        },

        year : function(y) {
            if(y && y > 0 && y <= 9999)
                this._year = y;
            else
                throw "undefined year";
        },

        month : function(m) {
            if(m && m>0 && m < 13) {
               this._month = m;
            }
            else
                throw "Invalid month " + m;
        },

        _leapYear : function() {
            var year = this._year;
            return year % 400 == 0 || (year % 100 != 0 && year % 4 == 0);
        },

        _maxDate : function(m) {
              if(this._leapYear() && m == 2)
                 return 29;
              else return DateInfo.dates[m-1];
        },

        day : function(d) {
            if(d && d > 0 && d <= this._maxDate(this._month || 0))
                this._day = d;
            else
                throw "Invalid Date "+ d + " for the month "+(this._month);
        },

        validate : function(y, m, d) {
                this.year(y);
                this.month(m);
                this.day(d);
        }
    });

    DateInfo.ParseIsoString = function(isoDateStr, locale){
		var isDateRegexp = /^(\d{4})(?:-?(\d{1,2})(?:-?(\d{1,2}))?)?(?:T((\d{2}):(\d{2}):(\d{2}))Z)?$/;
        var match = isDateRegexp.exec(isoDateStr);
        if(match && match.length >= 4){
            var dateInfo = new DateInfo();
            var date = new Date(isoDateStr);
            // TODO - check if date is invalid.
            if(match[4] && date != null) { // if time is available then use date object for conversion otherwise use previous approach to support invalid date like 2012-10-101, 2010-02-29 etc for RTC CQ-4201274
                dateInfo.year(date.getFullYear());
                dateInfo.month(date.getMonth()+1);
                dateInfo.day(date.getDate());
            } else {
                try {
                    dateInfo.year(Number(match[1]));
                    dateInfo.month(Number(match[2]));
                    dateInfo.day(Number(match[3]));
                } catch(e) {
                    return null;
                }
            }
            dateInfo.setDate();
            return dateInfo;
        }
        return null;
    };

    DateInfo.Parse = function(dateStr, locale, validateWithDefaultPatterns){
        locale = locale || "en_US";
        var patterns = xfalib.ut.PictureUtils.getLocaleObject(locale,"datePatterns"),
            isoDate = this.ParseIsoString(dateStr, locale);
        if(!_.isEmpty(isoDate)) {
            return isoDate;  // in case edit pattern is present, it'll be parsed by the widget during input and return an iso date string.
        }
        //if edit pattern is present then don't try to match it from default locale patterns.
        if(validateWithDefaultPatterns === false){
            _.find(patterns, function(pattern) {
                try {
                    isoDate = xfalib.ut.PictureFmt.parseDate(dateStr,pattern,locale);
                    return true;
                } catch(exception) {
                    return false;
                }
            });
        }
        isoDate = isoDate || dateStr;
        return DateInfo.ParseIsoString(isoDate);
    };

    DateInfo.dates = [31,28,31,30,31,30,31,31,30,31,30,31];
    DateInfo.daysOfWeek = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
})(_,xfalib);
/**
 * @package xfalib.ut.PictureEngine
 * @import xfalib.ut.Scanner
 * @fileOverview The file is a facade to assembly all components together.
 * @version 0.0.1
 */
(function(_,xfalib) {

    var PictureEngine = xfalib.ut.PictureEngine = xfalib.ut.Class.extend({

        _lookupNext: xfalib.ut.Scanner.lookupNext,

        MAX_XFA_PREC	: 8,		// Max no. of fractional digits in XFA.
        MAX_DBL_DIG	:18,		// Max no. of significant digits in a double.
        MAX_INT_DIG	:10,		// Max no. of significant digits in an integer.
        MAX_DBL_WIDTH	:15,		// Max width before precision loss in a double.
        INTEGRAL_FMT :  0,
        DECIMAL_FMT : 1,
        CURRENCY_FMT : 2,
        PERCENT_FMT : 3,

        parseDate : function(sSource, sPicture, locale){
            return this._acceptVisitor(new xfalib.ut.DateParsingVisitor({jsonModel:{_sPicture:sPicture,_dataString:sSource,_locale:this.jsonModel.locale}}));
        },

        formatDate : function(dDate, sPicture){
            var validateWithDefaultPatterns = typeof sPicture !== 'undefined';
            var dateInfo = xfalib.ut.DateInfo.Parse(dDate, this.jsonModel.locale, validateWithDefaultPatterns);
            if(dateInfo == null){
                return null;
            }else{
                return this._acceptVisitor(new xfalib.ut.DateFormattingVisitor({jsonModel:{_sPicture:sPicture,_dateInfo:dateInfo,_locale:this.jsonModel.locale}}));
            }
        },

        parseTime : function(sSource, sPicture){
            return this._acceptVisitor(new xfalib.ut.TimeParsingVisitor({jsonModel:{_sPicture:sPicture,_dataString:sSource}}));
        },

        formatTime : function(dDate, sPicture){
            var timeInfo = xfalib.ut.TimeInfo.Parse(dDate, this.jsonModel.locale);
            if(timeInfo == null){
                return null;
            }else{
                return this._acceptVisitor(new xfalib.ut.TimeFormattingVisitor({jsonModel:{_sPicture:sPicture,_timeInfo:timeInfo}}));
            }
        },

        parseText : function(sSource, sPicture){
            return this._acceptVisitor(new xfalib.ut.TextParsingVisitor({jsonModel:{_sPicture:sPicture,_dataString:sSource}}));
        },

        formatText : function(sSource, sPicture,bRelaxed){
            return this._acceptVisitor(new xfalib.ut.TextFormattingVisitor({jsonModel:{_sPicture:sPicture,_text:sSource,relaxed:bRelaxed}}));
        },

        parseNumeric : function(sSource, sPicture){
            var visitor = new xfalib.ut.NumParsingVisitor({jsonModel:{_sPicture:sPicture,_dataString:sSource,_locale:this.jsonModel.locale}}); // TODO : Is locale required
            visitor.parse();
            return visitor.getResult();
        },

       formatNumeric : function(sSource, sPicture,locale,bRelaxed,bFormatNumberFromasDefaultPC){

             var sFormatPicture =sPicture;
             if( bRelaxed && bFormatNumberFromasDefaultPC){
                 sFormatPicture = this.getNumberFormat(sPicture,1, {formatOption: "WITH_GROUPINGS",
                                      "precision"  : this.getNumberPrecision(sSource),
                                    "width"      : sSource.length
                                   });
             }
             return this._acceptVisitor(new xfalib.ut.NumFormattingVisitor({jsonModel:{_sPicture:sFormatPicture,_locale:this.jsonModel.locale},text:sSource}));
        },

        _acceptVisitor : function(visitor){
            this._scanPattern(visitor);
            return visitor.getResult();
        },

        _scanPattern : function(visitor){
            var patPos = 0;
            var sPicture = visitor.getPicture();
            for(var token = this._lookupNext(sPicture, patPos, visitor.acceptPatternChar); token != null;  ){
                visitor.consume(token);
                patPos = patPos + token.len;
                token = this._lookupNext(sPicture, patPos, visitor.acceptPatternChar);
            }
        },

       /**
          * Removes n bytes from this string starting at position nOffset.
         *
          * @param nOffset - start position for the remove
          * @param nLength - the number of characters to remove
          * @return This string
          */

         _swallow : function(sString , nOffset, nLenToSwallow)
         {
             if(_.isEmpty(sString) || nLenToSwallow ==0){
                 return sString;
             }

             if( (nOffset + nLenToSwallow)> sString.length ) {
                 nLenToSwallow = (nOffset + nLenToSwallow) - sString.length;
             }
            var subStr = sString.substr(0,nOffset) + sString.substr(offset + nLenToSwallow);

             return subStr
         },
         /**
         * Replace some portion of one string with another String.
          * @param sString - the String where it has to be replaced.
          * @param sReplacement - the replacement string.
          * @param nOffset - start position for the replacement. Default value = 0.
          * @param nCutLength - the number of bytes to remove from the
          * original string.
          */

         _replaceAll : function(sString ,sReplacement , nOffset ,nCutlength) {
             return sString.substr(0,nOffset) + sReplacement  + sString.substr(nOffset + nCutlength)
         },

         //----------------------------------------------------------------------
         // SkipOver
         //
         // Scan this string for the first byte of the character not in the given set.
         // Similar to strspn().
         //----------------------------------------------------------------------
         _skipOver : function(fromString,sSkip, nOffset)
         {
             // starting at the offset position, scan the characters in this string
             // until it does not match any of the characters in the given set.
            var nCharsSkipped = nOffset;
             var i = 0;
             while (nCharsSkipped < fromString.length)
             {
                 i = nCharsSkipped;
                 if (sSkip.indexOf(fromString[i]) ==-1) {
                     break;
                 }
                 i++;
                 nCharsSkipped = i;
             }

             return nCharsSkipped - nOffset;
         },

         /*
          * Get the numeric format in the given style.
          * @param style in the range of values 0-2,
          * where (0 = integral, 1 = decimal, 2 = currency).
          * @param option in the set of format options:
          */
         getNumberFormat : function(format , style, option)
        {
             if (style < this.INTEGRAL_FMT || this.PERCENT_FMT < style) {
                 style = this.DECIMAL_FMT;
             }

             var sFormat = format;

             //
             // Use any alternate part because they handle negative values.
             //
             var  nBar = 0;
             if ((nBar = sFormat.indexOf('|')) != -1) {
                 sFormat = this._swallow(sFormat, 0, nBar + 1);
             }
             //
             // Determine position of radix (or anything like it)
             // and the replicating part of the pattern, i.e., from
             // the separator to this radix.
            //
             var nDot;
             if ( (nDot = sFormat.indexOf('.')) == -1) {
                 if ((nDot = sFormat.indexOf('v')) == -1) {
                     if ((nDot = sFormat.indexOf('V')) == -1) {
                         if ((nDot = sFormat.indexOf('E')) == -1) {
                             if ((nDot = sFormat.indexOf(' ')) == -1) {
                                 if ((nDot = sFormat.indexOf('%')) == -1) {
                                     nDot = sFormat.length;
                                 }
                             }
                         }
                     }
                 }
             }
             if (nDot) {
                 if (this._skipOver(sFormat,"89zZ", nDot - 1) != 1) {
                     nDot = sFormat.length;
                 }
             }
             var sZZZ;
             var nZed;
             if ( (nZed = sFormat.indexOf("z,")) != -1) {
                 //
                 // Watson 1230768.  Handle locales, like India, that have
                 // pictures with more than one grouping symbol.
                //
                 var nSep = nDot;
                 var nComma;
                 if ((nComma = sFormat.indexOf(',', nZed + 2)) !=-1) {
                    nSep = nComma;
                 }
                 if (nSep > nZed + 2) {
                     sZZZ = Array(nSep - nZed).join('z');
                 }
                 else {
                     sZZZ = Array(1).join('z');
                 }
             }
             else {
                nZed = 0;
             }
             //
             // If non-integral styles Then determine width and precision.
             //
             var nPrec = 0;
             var nWidth = this.MAX_INT_DIG;
             if (style != this.INTEGRAL_FMT) {
                 nPrec = option.precision; // (option >> 8) & 0xff;
                 var trim = ((nPrec & 0x80) == 0);
                 nPrec &= 0x7f;
                 if (nPrec == 0x7f) {
                     nPrec = this._skipOver(sFormat, "89zZ", nDot + 1);
                 }
                 if ((option.width) != undefined) {
                     nWidth = option.width;
                 }
                 else {
                     nWidth = this.MAX_DBL_DIG;
                 }
                 //
                 // Fix for Watson 1229423.  If the locale's format contains
                 // any sign pictures Then widen accordingly.  Also widen if
                 // precision of locale's picture format is greater than requested.
                 //
                 if (sFormat.indexOf('s')!=-1) {
                     nWidth += 1;
                 }
                 if (sFormat.indexOf('(')!=-1) {
                     nWidth += 1;
                 }
                 if (sFormat.indexOf(')') !=-1) {
                     nWidth += 1;
                 }
                var nFmtPrec = this._skipOver(sFormat,"89zZ", nDot + 1);
                 if (0 < nPrec && nPrec < nFmtPrec) {
                     nWidth += nFmtPrec - nPrec;
                 }

                 //
                 // Pare down the precision if the width is big enough to yield
                 // IEEE 754 64-bit double precision errors, which appears to be
                 // anything over 14 significant digits.
                 //
                 if (trim && nPrec > 0 && nWidth > nPrec) {
                     //
                     // Fix for Watson 1211481.  If the given precision is less
                     // than what the locale's format dictates then widen the given
                     // width.
                    //
                     if (nPrec <= sFormat.length - 1 - nDot) {
                         nWidth += sFormat.length - 1 - nDot - nPrec;
                     }
                     for (var i = nWidth - 1; i > this.MAX_DBL_WIDTH; i--) {
                         //
                         // Never pare down the precision below what the locale's
                         // format dictates.
                         //
                         if (nPrec <= sFormat.length - 1 - nDot)
                            break;
                         nPrec--;
                     }
                 }
             }
             //Watson 1483675 - If the locale's format contains
             // a dollar sign or a space then widen accordingly.
             if (style == this.CURRENCY_FMT) {
                 if (sFormat.indexOf('$')!=-1) {
                     nWidth++;
                 }

                 if (sFormat.indexOf(' ')!=-1) {
                     nWidth += 1;
                }
             }

             //
             // If percent style was wanted Then truncate after the percent character.
             //
             if (style == this.PERCENT_FMT) {
                 var nTrim = this._skipOver(sFormat,"89zZ", nDot + 1);
                 sFormat = this._replaceAll(sFormat,"",nTrim,0)
                 //sFormat.Replace(jfString::EmptyString(), nDot + 1, nTrim);

                 //Watson 1483675 - If the locale's format contains
                 // a percent sign then widen accordingly.
                 if (sFormat.indexOf('%')!=-1) {
                     nWidth++;
                 }
             }
             //
             // Else if integral style was wanted Then truncate at the radix character.
             //
             //
             // If integral style was wanted Then truncate at the radix character.
             //
             else if (style == this.INTEGRAL_FMT || nPrec == 0){// && option.formatOption == "WITHOUT_RADIX") {
                 var nTrim = this._skipOver(sFormat,"89zZ", nDot + 1);
                 sFormat = this._replaceAll(sFormat,"",nDot,nTrim+1);
             }
             //
             // Otherwise for decimal and currency styles Do
             // replace fractional 'z' pictures with '8's to requested precision,
             //
             else if (option.formatOption == "WITH_EIGHTS") {
                 var nEight = nDot + 1;
                 while ((nEight =sFormat.indexOf('z'))!=-1) {
                     this._replaceAll(sFormat, '8', nEight,'8'.length);
                 }
                 while (sFormat.Length() - nDot <= nPrec) {
                     sFormat = this._replaceAll(sFormat, "8", nDot + 1, 0);
                 }
             }
             //
             // Or replace fractional '9' pictures with 'z's to requested precision
             // Watson 1322850 - add option to keep nines, previously this function
             // would force frac. digits to be either z's or 8's with no option for 9's.
             //
             else if ((option.formatOption) == "WITH_ZEDS" && !((option.formatOption) == "KEEP_NINES")) {
                 var nNine = nDot + 1;
                 while ((nNine = sFormat.indexOf('9'))!=-1) {
                     this._replaceAll(sFormat, 'z', nNine,1);
                 }
                 while (sFormat.Length() - nDot <= nPrec) {
                     this._replaceAll(sFormat, "z", nDot + 1, 0);
                 }
             }
             //
             // Replicate section from separator to radix to requested width.
             //
             if (!sZZZ) {
                 sZZZ = "z";
             }
            else if ((option.formatOption) == "WITHOUT_GROUPINGS" ) {
                 //
                 // Watson 1230768.  Handle locales, like India, that have
                 // pictures with more than one grouping symbol.
                 //
                 var nComma = nZed + 1 ;
                 this._replaceAll(sFormat, 'z' ,nComma,1);
                 while ( nComma!= -1 && (nComma < nDot)) {
                     nComma = sFormat.indexOf(',');
                     sFormat = this._replaceAll(sFormat,'z',nComma,1);
                 }
             }
             else if ((option.formatOption == "WITH_GROUPINGS")) {
                 sZZZ = this._replaceAll(sZZZ,',',0,1);
                 nWidth += (nWidth + sZZZ.length) / sZZZ.length;
             }
             while (sFormat.length < nWidth) {
                 sFormat = this._replaceAll(sFormat, sZZZ, nZed + 1, 0);
             }
             return sFormat;
         },

         /**
          * Get the decimal precision of the given numeric string.
          * @return the decimal precision or 0 for integral values.
          */
         getNumberPrecision: function(sVal)
         {
             var nRadix = 0;
             var i = -1;
             // Reason for not using the commented line. We are always storing the value in model with . as decimal separator
             // Passing field locale/ browser locale would lead to precision width being zero for non-english locales where
             // decimal separater may be different.
             // var rIndex = xfalib.ut.PictureUtils.getLocaleObject(this.jsonModel.locale,"numberSymbols").decimal;
             // so hardcoding . for now
             var rIndex = ".";
             if( (nRadix = sVal.indexOf(rIndex))!=-1)
             {
                     for(; nRadix <=sVal.length ;nRadix++) {
                         i++;
                     }

                 return i;
             }
             return 0;
          }
    })
})(_,xfalib);
/**
 * @package xfalib.ut.FormattingVisitorBase
 * @import xfalib.ut.VisitorBase
 * @fileOverview Base class for visitor
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String]}
 */

(function(_,xfalib) {
    var FormattingVisitorBase = xfalib.ut.FormattingVisitorBase = xfalib.ut.VisitorBase.extend({

        initialize: function() {
            this._buffer = []; //TODO: ASK Ren where does this _buffer comes from
            FormattingVisitorBase._super.initialize.call(this);
        },

        consumeStringWildCard : function(token){
            //'?' '*' '+
            this._buffer.push(" ");
        },

        consumeStringLiteral : function(token){
            this._buffer.push(this.jsonModel._sPicture.substr(token.startPos+1,token.len-2));
        },

        consumeCharLiteral : function(token){
            this._buffer.push(""+ this.jsonModel._sPicture.charAt(token.startPos));
        }
    })

})(_,xfalib);
/**
 * @package xfalib.ut.ParsingVisitorBase
 * @import xfalib.ut.VisitorBase
 * @fileOverview Base class for visitor
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String,_dataString: String}}
 */

(function(_,xfalib){
    var ParsingVisitorBase = xfalib.ut.ParsingVisitorBase = xfalib.ut.VisitorBase.extend({

        initialize: function() {
            this._strLen = this.jsonModel._dataString.length;
            this._strPos = 0;
            ParsingVisitorBase._super.initialize.call(this);
        },

        consumeStringWildCard : function(token){
            if (chr == '?') {
                if (this._strPos < this._strLen)//&& Character.isDefined(str.charAt(strPos))
                    this._strPos += 1;
            } else if (chr == '+') {
                if (this._strPos >= this._strLen)// || ! Character.isWhitespace(str.charAt(strPos)))
                    throw "Mismatch";
                this._strPos += 1;
                while (this._strPos < this._strLen)// && Character.isWhitespace(str.charAt(strPos)))
                    this._strPos += 1;
            } else if (chr == '*') {
                while (this._strPos < this._strLen)// && Character.isWhitespace(str.charAt(strPos)))
                    this._strPos += 1;
            }

        },

        consumeStringLiteral : function(token){
            for(var offset=0; offset<token.len-2 ;offset++){ //-2, heading and trailing quote
                if(this.jsonModel._sPicture.charAt(token.startPos+offset+1) != this.jsonModel._dataString.charAt(this._strPos+offset)){
                    throw ("Mismatch" + this.jsonModel._sPicture.substr(token.startPos, token.len));
                }
            }
            this._strPos += token.len-2;

        },

        consumeCharLiteral : function(token){
            if(this.jsonModel._sPicture.charAt(token.startPos) == this.jsonModel._dataString.charAt(this._strPos)){
                this._strPos += 1;
            }else{
                throw "Mismatch";
            }
        }
    })
})(_,xfalib);

/**
 * @package xfalib.ut.DateFormattingVisitor
 * @import xfalib.ut.FormattingVisitorBase
 * @fileOverview The file provides formating logic on date pattern characters.
 * @version 0.0.1
 */


/**
 * @constructor
 * @param object {jsonModel: {_sPicture:String,_dateInfo: xfalib.ut.DateInfo}}
 */

(function(_,xfalib) {
    var PictureUtils =  xfalib.ut.PictureUtils;
    var DateFormattingVisitor = xfalib.ut.DateFormattingVisitor = xfalib.ut.FormattingVisitorBase.extend({

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;

            switch (chr) {
                case 'D':
                    var dayOfMonth=this.jsonModel._dateInfo.date.getDate();
                    switch(chrCnt){
                        case 1:
                            break;
                        case 2:
                            dayOfMonth = PictureUtils.padding(dayOfMonth,2);
                            break;
                    }
                    this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,dayOfMonth));
                    break;
                case 'J':

                    //this._mDayOfYear;
                    break;
                case 'M':
                    var monthOfYear = this.jsonModel._dateInfo.date.getMonth();
                    switch(chrCnt){
                        case 1:
                            this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,monthOfYear+1));
                            break;
                        case 2:
                            this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,PictureUtils.padding(monthOfYear+1,2)));
                            break;
                        case 3:
                            var monthNames = PictureUtils.getLocaleObject(this.jsonModel._locale,"calendarSymbols.abbrmonthNames");
                            this._buffer.push(monthNames[monthOfYear]);
                            break;
                        case 4:
                            var monthNames = PictureUtils.getLocaleObject(this.jsonModel._locale,"calendarSymbols.monthNames");
                            this._buffer.push(monthNames[monthOfYear]);
                            break;
                    }

                    break;
                case 'E':
                    var dayOfWeek = this.jsonModel._dateInfo.date.getDay();
                    var dayNames;
                    switch(chrCnt) {
                        case 1:
                            this._buffer.push(dayOfWeek);
                            break;
                        case 3:
                            dayNames =  PictureUtils.getLocaleObject(this.jsonModel._locale,"calendarSymbols.abbrdayNames");
                            this._buffer.push(dayNames[dayOfWeek]);
                            break;
                        case 4:
                            dayNames =   PictureUtils.getLocaleObject(this.jsonModel._locale,"calendarSymbols.dayNames");
                            this._buffer.push(dayNames[dayOfWeek]);
                            break;
                        default:
                            throw "unsupported Picture Clause ";
                    }
                    break;
                case 'e':
                    break;
                case 'G':
                    break;
                case 'Y':

                    var yearOfEra = this.jsonModel._dateInfo.date.getFullYear()
                    switch(chrCnt){
                        case 2:
                            if(yearOfEra>2029 || yearOfEra < 1930){
                                throw "unsupported " + yearOfEra + " by pattern YY";
                            }
                            yearOfEra = PictureUtils.padding(yearOfEra % 100, 2);
                            break;
                        case 4:
                            yearOfEra = PictureUtils.padding(yearOfEra, 4); // 2 digit(0000-9999)
                            break;
                    }
                    this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,yearOfEra));
                    break;
                case 'w':
                    break;
                case 'W':
                    break;
                default: throw "Unsupported pattern";
            }

        },
        /**
         *
         * @override
         */
        getResult : function(){
            return this._buffer.join("");
        }

    });
})(_,xfalib);


/**
 * @package xfalib.ut.TextFormattingVisitor
 * @import xfalib.ut.FormattingVisitorBase
 * @fileOverview Formats a string according to Text Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object { jsonModel:{_sPicture: String, _text: String}}
 */
(function(_,xfalib){
    var TextFormattingVisitor = xfalib.ut.TextFormattingVisitor = xfalib.ut.FormattingVisitorBase.extend({

        initialize: function() {
            this._textPos = 0;
            this._relaxed = typeof this.jsonModel.relaxed === "undefined" ? true: this.jsonModel.relaxed;
            TextFormattingVisitor._super.initialize.call(this);
        },

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;
            for(var index = 0; index < chrCnt && (!this._relaxed || this._textPos < this.jsonModel._text.length); index++){
                switch (chr) {
                    case '9': // Numeric
                        var cUni = this.jsonModel._text.charAt(this._textPos++);
                        if(!xfalib.ut.PictureUtils.isDigit(cUni)){
                            throw "TextFormatting: not a digit as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'A': // Alphebetic
                        var cUni = this.jsonModel._text.charAt(this._textPos++);
                        if(!xfalib.ut.PictureUtils.isLetter(cUni)){
                            throw "TextFormatting: not a character as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'O': // Alphanumeric
                    case '0':
                        var cUni = this.jsonModel._text.charAt(this._textPos++);
                        // cUni === "" is a hack for LC-6152
                        // To prevent extra loop[one more time than the length of the string] for which cUni was ""
                        // which was neither a letter nor a digit
                        // so we were getting textformatting error
                        //which caused email id validation to fail for chars less than picture clause
                        if(!(cUni ==="" || xfalib.ut.PictureUtils.isLetter(cUni) || xfalib.ut.PictureUtils.isDigit(cUni))){
                            throw "TextFormatting: not a character or digit as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'X':
                        var cUni = this.jsonModel._text.charAt(this._textPos++);
                        this._buffer.push(cUni);
                        break;
                    case 't':
                        this._buffer.push("\t");
                        break;
                    default: this._buffer.push(chr);
                }
            }

        },

        /**
         *
         * @override
         */
        getResult : function(){
            if(this._textPos < this.jsonModel._text.length)
                throw "TextFormatting: picture clause smaller than input Text";
            return this._buffer.join("");
        },

        /**
         *
         * @override
         */
        acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "9AO0Xt");
        },

        consumeCharLiteral : function(token){
         this._buffer.push(""+ this.jsonModel._sPicture.charAt(token.startPos));
         // LC-3869 : forward the text pointer after literal is present and matched with the picture.
         if(this.jsonModel._sPicture.charAt(token.startPos) == this.jsonModel._text.charAt(token.startPos))
             this._textPos++;
        }
    })

})(_,xfalib);


/**
 * @package xfalib.ut.TextFormattingVisitor
 * @import xfalib.ut.FormattingVisitorBase
 * @fileOverview The file provides formating logic on date pattern characters.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param object {jsonModel: {_sPicture:String,_timeInfo: xfalib.ut.TimeInfo}}
 */

(function(_,xfalib){
    var TimeFormattingVisitor = xfalib.ut.TimeFormattingVisitor=  xfalib.ut.FormattingVisitorBase.extend({

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;

            switch (chr) {
                case 'H':
                case 'K':
                    var hourOfDay = this.jsonModel._timeInfo.mHourOfDay;
                    if(chr=='K'){
                        hourOfDay += 1;
                    }
                    switch(chrCnt){
                        case 1:
                            this._buffer.push(hourOfDay);
                            break;
                        case 2:
                            this._buffer.push(xfalib.ut.PictureUtils.padding(hourOfDay,2));
                            break;
                    }
                    break;

                case 'M':
                    var minuteOfHour = this.jsonModel._timeInfo.mMinuteOfHour;
                    switch(chrCnt){
                        case 1:
                            this._buffer.push(minuteOfHour);
                            break;
                        case 2:
                            this._buffer.push(xfalib.ut.PictureUtils.padding(minuteOfHour,2));
                            break;
                    }

                    break;
                case 'S':
                    var secondOfMinute = this.jsonModel._timeInfo.mSecondOfMinute;
                    switch(chrCnt){
                        case 1:
                            this._buffer.push(secondOfMinute);
                            break;
                        case 2:
                            this._buffer.push(xfalib.ut.PictureUtils.padding(secondOfMinute,2));
                            break;
                    }
                    break;
                case 'F':
                    var Milliseconds =this.jsonModel._timeInfo.mThousandthOfSecond;
                    this._buffer.push(xfalib.ut.PictureUtils.padding(Milliseconds,3));
                    break;

                default: throw "Unsupported pattern";
            };

        },

        /**
         *
         * @override
         */
        getResult : function(){
            return this._buffer.join("");
        }

    });

})(_,xfalib);


/**
 * @package xfalib.ut.NumFormattingVisitor
 * @import xfalib.ut.FormattingVisitorBase
 * @fileOverview Formats a string according to Text Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object { jsonModel:{_sPicture: String}, text: String}
 */

(function(_,xfalib){
    var PictureUtils =  xfalib.ut.PictureUtils;
    var NumFormattingVisitor = xfalib.ut.NumFormattingVisitor = xfalib.ut.FormattingVisitorBase.extend({

        initialize: function(options) {
            NumFormattingVisitor._super.initialize.call(this);
            this._textPos = 0;

            //boolean value used for internal state track
            this._mbDigitAddedToOutput = false; // at least one digit has been added to output
            this._mbSignAddedToOutput = false;
            this._nScannedPatternDigit = 0; //how many digit(98Zz) characters scanned in pattern, reset to 0 after '.Vv'
            this._mbRadixSeen = false;

            this._pictureDesc = new xfalib.ut.NumPictureDesc({jsonModel:{_sPicture:this.jsonModel._sPicture}});
            this.jsonModel._sPicture= this._pictureDesc.getPicture();
            this._numberInfo = this._pictureDesc.parseNumberInfo(options.text);

            this._mbNegative = this._numberInfo.isNegative;
            this._msText = this._numberInfo.msText;
            this._leadingPadding = this._numberInfo.padding;
            //
            this._mNumberSymbols = xfalib.ut.PictureUtils.getLocaleObject(this.jsonModel._locale,"numberSymbols");
            this._mCurrencySymbols = xfalib.ut.PictureUtils.getLocaleObject(this.jsonModel._locale,"currencySymbols");
        },

        _checkAndAddDecimalPoint: function(fw) {
            if(this._mAddRadix) {
                this._buffer.push(this._fmtStr(this._mNumberSymbols.decimal, fw));
                this._mAddRadix = false;
            }
        },

        consumeSubPattern : function(token){
            var chr = token.patChar,
                chrCnt = token.len;
            switch (chr) {
                case '9':
                case '8':
                case 'Z': // Digit or space if zero.
                case 'z':// Digit or nothing if zero.
                    if(!this._mbSignAddedToOutput)
                        this._ensureSignIsAdded();
                    while (chrCnt-- > 0 ) {
                        if(!this._mbRadixSeen){
                            if(this._leadingPadding > this._nScannedPatternDigit++){
                                var placeHolder = null;
                                if(this._mbDigitAddedToOutput){
                                    placeHolder = this._mNumberSymbols.zero;
                                }else{
                                    if(chr == '9' || chr =='8') {
                                        placeHolder = this._mNumberSymbols.zero;
                                        this._mbDigitAddedToOutput = true;
                                    }else if(chr == 'Z'){
                                        placeHolder = " ";
                                    }
                                }
                                if(placeHolder){
                                    this._buffer.push(this._matchChr(placeHolder));
                                }
                            }else {
                                var cValue = this._msText.charAt(this._textPos++);
                                this._ensureCharIsDigit(cValue);
                                this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,cValue));
                                this._mbDigitAddedToOutput = true;
                            }
                        }else{  //handling fractional part
                            if(this._nScannedPatternDigit++  < this._numberInfo.fractionDigit ){
                                var cValue = this._msText.charAt(this._textPos++);
                                this._ensureCharIsDigit(cValue);
                                this._checkAndAddDecimalPoint();
                                this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,cValue));
                                this._mbDigitAddedToOutput = true;
                            }else{
                                if(chr == '9'|| chr =='Z') {
                                    this._checkAndAddDecimalPoint();
                                    this._buffer.push(this._matchChr(this._mNumberSymbols.zero));
                                } else if(chr == '8') {
                                    var cValue = this._msText.charAt(this._textPos++);
                                    if(cValue != '' && this._ensureCharIsDigit(cValue)) {
                                        this._checkAndAddDecimalPoint();
                                        this._buffer.push(PictureUtils.convertNumberToLocale(this.jsonModel._locale,cValue));
                                        this._mbDigitAddedToOutput = true;
                                    }
                                }
                            }
                        }

                    }

                    break;
                case 'E': // Exponent.
                    this._buffer.push('E');
                    this._buffer.push("" + this._numberInfo.shift);
                    break;
                case 'C': // CR symbol if negative and spaces if positive.
                    this._buffer.push((this._mbNegative) ? xfalib.ut.NumPictureDesc.gsCR : xfalib.ut.NumPictureDesc.gsDSP);
                    break;
                case 'c': // CR symbol if negative and nothing if positive.
                    if (this._mbNegative){
                        this._buffer.push(xfalib.ut.NumPictureDesc.gsCR);
                    }
                    break;
                case 'D': // DB symbol if negative and spaces if positive.
                    this._buffer.push((this._mbNegative) ? xfalib.ut.NumPictureDesc.gsDB : xfalib.ut.NumPictureDesc.gsDSP);
                    break;
                case 'd': // DB symbol if negative and nothing if positive.
                    if (this._mbNegative){
                        this._buffer.push(xfalib.ut.NumPictureDesc.gsDB);
                    }
                    break;
                case 'S': // Minus sign if negative and a space if positive.
                case 's':
                    if (this._mbNegative){
                        this._buffer.push(this._fmtStr(	this._mNumberSymbols.minus));
                    }else{
                        if('S' == chr){
                            this._buffer.push(this._matchChr(' '));
                        }
                    }
                    break;
                case 'V': // Implied decimal sign if parsing.
                case '.':
                case 'v': // Implied decimal sign.
                    if (this._textPos < this._msText.length && this._msText.charAt(this._textPos) == '.'){
                        this._textPos++; //consume a '.'
                    }
                    if (chr == 'V' || chr == '.'){
                        this._mAddRadix = true;
                        //this._buffer.push(this._fmtStr(this._mNumberSymbols.decimal, ));
                    }
                    this._mbRadixSeen = true;
                    this._nScannedPatternDigit = 0;
                    break;

                case 0xFF0C: // Fullwidth ','.
                case ',': // Grouping separator.
                    while (chrCnt-- > 0) {
                        if (this._mbDigitAddedToOutput){
                            this._buffer.push(this._fmtStr(	this._mNumberSymbols.grouping ));
                        }
                        this._mbCommaSeen = true;
                    }
                    break;
                case 0xFF04: // Fullwidth '$'.
                case '$': // Currency name or symbol.
                    while (chrCnt-- > 0) {
                        this._buffer.push(this._fmtStr(	this._mCurrencySymbols.symbol ));
                    }
                    break;
                case 0xFF05: // Fullwidth '%'.
                case '%': // Percent symbol.
                    while (chrCnt-- > 0) {
                        this._buffer.push(this._fmtStr(	this._mNumberSymbols.percent));
                    }
                    break;
                case 0xFF08: // Fullwidth '('.
                case 0xFF09: // Fullwidth ')'.
                case '(': // Left parenthesis.
                case ')': // Right parenthesis.
                    this._buffer.push(this._matchChr((this._mbNegative) ? chr : ' '));
                    break;
                default:
            }
        },

        _ensureCharIsDigit : function(cValue){
            if ('0' > cValue || cValue > '9'){
                throw "Nuberic Formatting: not a digit as expected " + cValue;
            }
        },


        _fmtStr : function(str){
            return str;
        },

        _matchStr : function(str){
            return str;
        },

        _matchChr : function(str){
            return str;
        },

        _ensureSignIsAdded : function(){
            if (this._mbNegative && ! this._mbDigitAddedToOutput && ! this._pictureDesc.hasSign) {
                this._buffer.push(this._mNumberSymbols.minus);
                this._mbSignAddedToOutput = true;
            }
        },

        /**
         *
         * @override
         */
        getResult : function(){
            return this._buffer.join("");
        },

        /**
         *
         * @override
         */
        acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "(%$,.)89BCDERSVZbcdrsvzt");
        }

    });

})(_,xfalib);


/**
 * @package xfalib.ut.TimeParsingVisitor
 * @import xfalib.ut.ParsingVisitorBase
 * @fileOverview The file provides parsing/formating logic on date pattern characters.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String, _dataString: String]}
 */

(function(_,xfalib){
    var TimeParsingVisitor = xfalib.ut.TimeParsingVisitor = xfalib.ut.ParsingVisitorBase.extend({

        initialize: function() {
            this._timeInfo = new xfalib.ut.TimeInfo();
            TimeParsingVisitor._super.initialize.call(this);
        },

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;
            var curPos = this._strPos;
            var scannedChar = chrCnt;
            this._assert(curPos+chrCnt <=this.jsonModel._dataString.length, "Mismatch");

            switch (chr) {
                case 'h':
                    if(this._timeInfo.mHourOfMeriDiem != -1 || this._timeInfo.mHourOfDay != -1){
                        throw "ambiguity time string";
                    }
                    var hourOfMeriDiem=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-12)
                            hourOfMeriDiem = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            hourOfMeriDiem = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-12)
                            break;
                    }

                    this._timeInfo.mHourOfMeriDiem = hourOfMeriDiem -1;
                    this._assert(this._timeInfo.mHourOfMeriDiem>=0 && this._timeInfo.mHourOfMeriDiem<=11, "Invalid Hour Of MeriDiem value.");
                    break;

                case 'k':
                    if(this._timeInfo.mHourOfMeriDiem != -1 || this._timeInfo.mHourOfDay != -1){
                        throw "ambiguity time string";
                    }
                    var hourOfMeriDiem=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-11)
                            hourOfMeriDiem = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            hourOfMeriDiem = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-11)
                            break;
                    }

                    this._timeInfo.mHourOfMeriDiem = hourOfMeriDiem;
                    this._assert(this._timeInfo.mHourOfMeriDiem>=0 && this._timeInfo.mHourOfMeriDiem<=11, "Invalid hour of meriDiem value.");
                    break;

                case 'H':
                    if(this._timeInfo.mHourOfMeriDiem != -1 || this._timeInfo.mHourOfDay != -1){
                        throw "ambiguity time string";
                    }
                    var hourOfDay=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-23)
                            hourOfDay = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            hourOfDay = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-23)
                            break;
                    }

                    this._timeInfo.mHourOfDay = hourOfDay;
                    this._assert(this._timeInfo.mHourOfDay>=0 && this._timeInfo.mHourOfDay<=23, "Invalid hour of day value.");
                    break;

                case 'K':
                    if(this._timeInfo.mHourOfMeriDiem != -1 || this._timeInfo.mHourOfDay != -1){
                        throw "ambiguity time string";
                    }
                    var hourOfDay=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-23)
                            hourOfDay = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            hourOfDay = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-23)
                            break;
                    }

                    this._timeInfo.mHourOfDay = hourOfDay - 1;
                    this._assert(this._timeInfo.mHourOfDay>=0 && this._timeInfo.mHourOfDay<=23, "Invalid hour of day value.");
                    break;
                case 'M':
                    if(this._timeInfo.mMinuteOfHour != -1){
                        throw "ambiguity time string";
                    }
                    var minuteOfHour=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-59)
                            minuteOfHour = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            minuteOfHour = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-59)
                            break;
                    }

                    this._timeInfo.mMinuteOfHour = minuteOfHour;
                    this._assert(this._timeInfo.mMinuteOfHour>=0 && this._timeInfo.mMinuteOfHour<=59, "Invalid minute of hour.");
                    break;
                case 'S':
                    if(this._timeInfo.mSecondOfMinute != -1){
                        throw "ambiguity time string";
                    }
                    var secondOfMinute=-1;
                    switch(chrCnt){
                        case 1:
                            var parsed = this.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-59)
                            secondOfMinute = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            secondOfMinute = this.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(0-59)
                            break;
                    }

                    this._timeInfo.mSecondOfMinute = secondOfMinute;
                    this._assert(this._timeInfo.mSecondOfMinute>=0 && this._timeInfo.mSecondOfMinute<=59, "Invalid second of minute.");
                    break;
                case 'F':

                    this._assert(chrCnt==3, "Invalid pattern F.");
                    this._timeInfo.mThousandthOfSecond = this.parseIntExact(this.jsonModel._dataString, curPos, 3);
                    this._assert(this._timeInfo.mThousandthOfSecond>=0 && this._timeInfo.mThousandthOfSecond<=999, "Invalid thousand of second.");
                    break;

                default: throw "Unsupported pattern";
            }

            this._strPos += scannedChar;
        },

        parseIntAggressive : xfalib.ut.PictureUtils.parseIntAggressive,

        parseIntExact : xfalib.ut.PictureUtils.parseIntExact,

        getResult : function(){
            return this._timeInfo.getISOTime();
        },

        getTimeInfo : function(){
            return this._timeInfo;
        },

        _assert : function(condition, message){
            if(!condition){
                throw message;
            }
        }
    });
})(_,xfalib);



/**
 * @package xfalib.ut.TextParsingVisitor
 * @import xfalib.ut.ParsingVisitorBase
 *
 * @fileOverview Parses a string according to Text Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String, _dataString: String]}
 */
(function(_,xfalib){
    var TextParsingVisitor = xfalib.ut.TextParsingVisitor = xfalib.ut.ParsingVisitorBase.extend({

        initialize: function() {
            TextParsingVisitor._super.initialize.call(this);
            this._buffer = [];
        },

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;
            for(var index = 0; index < chrCnt; index++){
                switch (chr) {
                    case '9': // Numeric
                        var cUni = this.jsonModel._dataString.charAt(this._strPos++);
                        if(!xfalib.ut.PictureUtils.isDigit(cUni)){
                            throw "TextParsing: not a digit as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'A': // Alphebetic
                        var cUni = this.jsonModel._dataString.charAt(this._strPos++);
                        if(!xfalib.ut.PictureUtils.isLetter(cUni)){
                            throw "TextParsing: not a character as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'O': // Alphanumeric
                    case '0':
                        var cUni = this.jsonModel._dataString.charAt(this._strPos++);
                        if(!xfalib.ut.PictureUtils.isLetterOrDigit(cUni)){
                            throw "TextParsing: not a character or digit as expected";
                        }
                        this._buffer.push(cUni);
                        break;
                    case 'X':
                        var cUni = this.jsonModel._dataString.charAt(this._strPos++);
                        this._buffer.push(cUni);
                        break;
                    case 't':
                        if(this.jsonModel._dataString.charAt(this._strPos++)=="\t"){
                            this._buffer.push("\t");
                        }else{
                            throw "TextParsing: not a Tab as expected";
                        }
                        break;
                    default:
                        if(this.jsonModel._dataString.charAt(this._strPos++)== chr){
                            this._buffer.push(chr);
                        }else{
                            throw "TextParsing: not '" + chr+"' as expected";
                        }
                }
            }

        },
        /**
         *
         * @override
         */
        getResult : function(){
            if(this._strPos < this.jsonModel._dataString.length)
                throw "TextParsing: picture clause smaller than input Text";
            return this._buffer.join("");
        },
        /**
         *
         * @override
         */
        acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "9AO0Xt");
        }

    });
})(_,xfalib);


/**
 * @package xfalib.ut.NumParsingVisitor
 * @import xfalib.ut.ParsingVisitorBase
 * @fileOverview Parses a string according to Text Picture.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String,_dataString: String}}
 */

(function(_,xfalib){
    var NumParsingVisitor = xfalib.ut.NumParsingVisitor = xfalib.ut.ParsingVisitorBase.extend({

        initialize: function(options) {
            this._pictureDesc = new xfalib.ut.NumPictureDesc({jsonModel:{_sPicture:this.jsonModel._sPicture}});
            this.jsonModel._sPicture = this._pictureDesc.getPicture();
            this._buffer = [];
            this._strPos = 0;
            this._hasRadix = false;
            this._mbNegative = false;
            this._mbDigitSeen = false; // at least one digit has been added to output
            this._mbSignSeen = false;
            this._mBacktrack = null;
            this._hasPercent = false;
            this._mbExponSeen = false;

            this._mNumberSymbols = xfalib.ut.PictureUtils.getLocaleObject(this.options._locale,"numberSymbols");
            this._mCurrencySymbols = xfalib.ut.PictureUtils.getLocaleObject(this.options._locale,"currencySymbols");
        },

        _lookupNext : xfalib.ut.Scanner.lookupNext,

        parse : function(){
            var patPos = 0;
            while(true){
                try{
                    for(var token = this._lookupNext(this.jsonModel._sPicture, patPos, this.acceptPatternChar); token != null;  ){
                        this.consume(token);
                        patPos = patPos + token.len;
                        token = this._lookupNext(this.jsonModel._sPicture, patPos, this.acceptPatternChar);
                    }
                }catch(e){
                    //mismatch, try again!
                    if(this._mBacktrack){
                        patPos = this._mBacktrack.patPos;
                        this._buffer.length = 0;
                        this._strPos = this._mBacktrack.strPos;
                        this._mbDigitSeen = false;
                        this._mBacktrack = null;
                        continue;
                    }
                }
                break;
            }
        },
        consumeSubPattern : function(token){

            var chr = token.patChar;
            var chrCnt = token.len;
            var fw = false;
            switch (chr) {
                case '9':
                case '8':
                case 'Z': // Digit or space if zero.
                case 'z':// Digit or nothing if zero.
                    while (chrCnt-- > 0 ) {
                        if(!this._mbDigitSeen){
                            var cUni = this.jsonModel._dataString.charAt(this._strPos);
                            if(cUni == '-'){
                                this._mbNegative = true;
                                cUni = this.jsonModel._dataString.charAt(++this._strPos);
                            }
                            if(chr== '9' || chr == '8'){
                                if(!xfalib.ut.PictureUtils.isDigit(cUni)){
                                    throw "TextParsing: not a digit as expected";
                                }
                                this._buffer.push(cUni);
                                this._mbDigitSeen =true;
                            }else if(chr =='Z'){
                                if(xfalib.ut.PictureUtils.isDigit(cUni)){
                                    this._buffer.push(cUni);
                                    this._mbDigitSeen =true;
                                }else if(cUni != ' '){
                                    throw "TextParsing: not a digit or space as expected";
                                }
                            }else {
                                // has to be 'z', eagerly try to match a digit, if a mismatch is latterly found, backtrack
                                if(xfalib.ut.PictureUtils.isDigit(cUni)){
                                    this._buffer.push(cUni);
                                    this._mbDigitSeen =true;
                                    this._mBacktrack = {
                                        "patPos" : token.patPos + token.len - chrCnt, //new position from next char after 'z'
                                        "strPos" : this._strPos
                                    };
                                }else {
                                    throw "TextParsing: not a digit or space as expected";
                                }
                            }
                            ++this._strPos;
                        }else{
                            var cUni = this.jsonModel._dataString.charAt(this._strPos);
                            if(xfalib.ut.PictureUtils.isDigit(cUni)){
                                this._buffer.push(cUni);
                                ++this._strPos;
                            }else{
                                if(chr !='z'){
                                    throw "TextParsing: not a digit as expected";
                                }else{
                                    ++this._strPos;
                                }
                            }
                        }
                    }

                    break;
                case 'V' :
                case 'v' :
                case '.' :
                    if(this._matchStr(this._mNumberSymbols.decimal)){
                        this._hasRadix = true;
                        this._buffer.push('.');
                        this._mbDigitSeen =true;
                    }else{
                        throw "TextParsing: not a radix as expected";
                    }
                    break;
                case 'E': // Exponent.
                    if(this._matchStr('E')){
                        this._buffer.push('E');
                        if(this._matchStr('+')){
                            //
                        }else if(this._matchStr('-')){
                            this.jsonModel._buffer.push('-');
                        }
                        var strLen = this.jsonModel._dataString.length;
                        while(this._strPos < strLen &&
                            xfalib.ut.PictureUtils.isDigit(this.jsonModel._dataString.charAt(this._strPos))){
                            this._buffer.push(this.jsonModel._dataString.charAt(this._strPos++));
                        }
                    }
                    break;

                case 'C': // CR symbol if negative and spaces if positive.
                    if(this._matchStr(xfalib.ut.NumPictureDesc.gsCR)){
                        this._mbNegative = true;
                    }else if(!this._matchStr(xfalib.ut.NumPictureDesc.gsDSP)){
                        throw "TextParsing: not a CR as expected";
                    }
                    break;
                case 'c': // CR symbol if negative and nothing if positive.
                    if(this._matchStr(xfalib.ut.NumPictureDesc.gsCR)){
                        this._mbNegative = true;
                    }
                    break;
                case 'D': // DB symbol if negative and spaces if positive.
                    if(this._matchStr(xfalib.ut.NumPictureDesc.gsDB)){
                        this._mbNegative = true;
                    }else if(!this._matchStr(xfalib.ut.NumPictureDesc.gsDSP)){
                        throw "TextParsing: not a CR as expected";
                    }
                    break;
                case 'd': // DB symbol if negative and nothing if positive.
                    if(this._matchStr(xfalib.ut.NumPictureDesc.gsDB)){
                        this._mbNegative = true;
                    }
                    break;
                case 'S': // Minus sign if negative and a space if positive.
                    if(this._matchStr(this._mNumberSymbols.negative,fw)){
                        this._mbNegative = true;
                    }else if(!this._matchStr(" ")){
                        throw "TextParsing: not a CR as expected";
                    }
                    break;
                case 's':
                    if(this._matchStr(this._mNumberSymbols.negative,fw)){
                        this._mbNegative = true;
                    }
                    break;
                case 0xFF0C: // Fullwidth ','.
                case ',': // Grouping separator.
                    while (chrCnt-- > 0) {
                        if(!this._matchStr(this._mNumberSymbols.grouping, fw)){
                            throw "TextParsing: not a grouping symbol as expected";
                        }
                    }
                    break;
                case 0xFF04: // Fullwidth '$'.
                case '$': // Currency name or symbol.
                    while (chrCnt-- > 0) {
                        if(!this._matchStr(this._mCurrencySymbols.symbol, fw)){
                            throw "TextParsing: not a grouping symbol as expected";
                        }
                    }
                    break;
                case 0xFF05: // Fullwidth '%'.
                case '%': // Percent symbol.
                    while (chrCnt-- > 0) {
                        if(!this._matchStr(this._mNumberSymbols.percent, fw)){
                            throw "TextParsing: not a grouping symbol as expected";
                        }
                    }
                    this._hasPercent = true;
                    break;
                case 0xFF08: // Fullwidth '('.
                case 0xFF09: // Fullwidth ')'.
                case '(': // Left parenthesis.
                case ')': // Right parenthesis.
                    if(this._matchStr(chr,fw)){
                        this._mbNegative = true;
                    }else if(!this._matchStr(" ")){
                        throw "TextParsing: not parentesis as expected";
                    }
                    break;
                case 't': // tab.
                    while (chrCnt-- > 0) this._matchStr('\t',fw);
            }
        },
        getResult : function(){
            var stringNum =  this._buffer.join("");
            if(this._hasPercent) {
                var buf = new Array();
                stringNum = Number(stringNum).toString();
                var dot = stringNum.indexOf('.');

                var pos = dot-2;
                if(pos ==0) buf.push("0");
                else if(pos ==-1) buf.push("0.0");
                else if(pos ==-3) pos = stringNum.length - 2;
                for(var index=0;index < stringNum.length; index++){
                    if(index == pos){
                        buf.push(".");
                    }
                    if(index != dot){
                        buf.push(stringNum.charAt(index));
                    }
                }
                stringNum = buf.join("");
            }
            var number = Number(stringNum);
            if(this._mbNegative) number = -number;
            return number.toString();
        },

        _matchStr : function(target){
            if(xfalib.ut.PictureUtils.matchString(this.jsonModel._dataString, this._strPos, target)){
                this._strPos+= target.length;
                return true;
            }else{
                return false;
            }
        },

        /**
         *
         * @override
         */
        acceptPatternChar : function(chr){
            return xfalib.ut.PictureUtils.inString(chr, "(%$,.)89BCDERSVZbcdrsvzt");
        }
    });
})(_,xfalib);
/**
 * @package xfalib.ut.DateParsingVisitor
 * @import xfalib.ut.ParsingVisitorBase
 * @fileOverview The file provides parsing/formating logic on date pattern characters.
 * @version 0.0.1
 */

/**
 * @constructor
 * @param Object {jsonModel: {_sPicture: String, _dataString: String]}
 */

(function(_,xfalib) {
    var DateParsingVisitor = xfalib.ut.DateParsingVisitor = xfalib.ut.ParsingVisitorBase.extend({

        initialize: function() {
            this._dateInfo = new xfalib.ut.DateInfo({isParsingCall : true});
            this._dayOfMonth = this._monthOfYear = this._yearOfEra = null; // used to validate date once all sub patterns are consumed
            DateParsingVisitor._super.initialize.call(this);
        },

        consumeSubPattern : function(token){
            var chr = token.patChar;
            var chrCnt = token.len;
            var curPos = this._strPos;
            var scannedChar = chrCnt;

            //TODO: need to remove this assert.
            this._assert(curPos+chrCnt <=this.jsonModel._dataString.length, "Mismatch");

            switch (chr) {
                case 'D':
                    switch(chrCnt){
                        case 1:
                            var parsed = xfalib.ut.PictureUtils.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-31)
                            this._dayOfMonth = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            this._dayOfMonth = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-31)
                            break;
                    }
                    this._assert(this._dayOfMonth <= 31 && this._dayOfMonth >0, "Invalid date string1");
                    break;
                case 'J':

                    //this._mDayOfYear;
                    break;
                case 'M':
                    var symbol = "";
                    switch(chrCnt){
                        case 1:
                            var parsed = xfalib.ut.PictureUtils.parseIntAggressive(this.jsonModel._dataString, curPos, 2); // 1-2 digit(1-12)
                            this._monthOfYear = parsed.value;
                            scannedChar = parsed.len;
                            break;
                        case 2:
                            this._monthOfYear = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._dataString, curPos, 2); // 2 digit(01-12)
                            break;
                        case 3:
                            symbol = "calendarSymbols.abbrmonthNames";
                            break;
                        case 4:
                            symbol = "calendarSymbols.monthNames"
                            break;

                    }
                    if(symbol) {
                        var hashObj = xfalib.ut.PictureUtils.getHashOfLocaleObject(this.jsonModel._locale,symbol),
                            str = this.jsonModel._dataString.toLowerCase(),
                            hash = 0,
                            curStr = ""
                        scannedChar = 0;
                        while(curPos+scannedChar < str.length) {
                            hash += (scannedChar+1)*str.charCodeAt(curPos+scannedChar)
                            curStr+= str.charAt(curPos+scannedChar);
                            scannedChar++;
                            if(hashObj[hash] && hashObj[hash].indexOf(curStr) > -1 ) break;
                        }
                        var monthNames = _.map(xfalib.ut.PictureUtils.getLocaleObject(this.jsonModel._locale, symbol), function (str) {
                            return str.toLowerCase();
                        });
                        this._monthOfYear = monthNames.indexOf(curStr) + 1; // months are from 1 to 12
                    }
                    //TODO: remove this assert
                    this._assert(this._monthOfYear <= 12 && this._monthOfYear >0, "Invalid date string2");
                    break;
                case 'E':
                    var symbol = ""
                    switch(chrCnt) {
                        case 1:
                            scannedChar = 1;
                            break;
                        case 3:
                            symbol = "calendarSymbols.abbrdayNames";
                            break;
                        case 4:
                            symbol = "calendarSymbols.dayNames"
                            break;
                        default:
                            throw "unsupported Picture Clause ";
                    }
                    if(symbol) {
                        var hashObj = xfalib.ut.PictureUtils.getHashOfLocaleObject(this.jsonModel._locale,symbol);
                        scannedChar = 0;
                        var str = this.jsonModel._dataString.toLowerCase();
                        var hash = 0;
                        var curStr = "";
                        while(curPos+scannedChar < str.length) {
                            hash += (scannedChar+1)*str.charCodeAt(curPos+scannedChar)
                            curStr+= str.charAt(curPos+scannedChar);
                            scannedChar++;
                            if(hashObj[hash] && hashObj[hash].indexOf(curStr) > -1) break;
                        }
                    }
                    break;

                case 'e':
                    break;
                case 'G':
                    break;
                case 'Y':

                    switch(chrCnt){
                        case 2:
                            this._yearOfEra = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._dataString, curPos, 2); // 2 digit(00-99)
                            this._yearOfEra+=2000;
                            if(this._yearOfEra >= 2029){
                                this._yearOfEra -=100;
                            }
                            break;
                        case 4:
                            this._yearOfEra = xfalib.ut.PictureUtils.parseIntExact(this.jsonModel._dataString, curPos, 4); // 2 digit(0000-9999)
                            break;
                    }

                    this._assert(this._yearOfEra <= 9999 && this._yearOfEra >=0, "Invalid date string3");
                    break;
                case 'w':
                    break;
                case 'W':
                    break;
                default: throw "Unsupported pattern";
            }

            if(this._yearOfEra && this._monthOfYear && this._dayOfMonth){
                this._dateInfo.validate(this._yearOfEra, this._monthOfYear, this._dayOfMonth);
            }

            this._strPos += scannedChar;
        },

        getDate : function(){
            return this._dateInfo.date;
        },

        getResult: function(){
            if (this._strPos < this.jsonModel._dataString.length) {
                throw "DateParsing: picture clause smaller than input Date";
            }
            return this._dateInfo.getISODate();
        },

        _assert : function(condition, message){
            if(!condition){
                throw message;
            }
        }
    });
})(_,xfalib);

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/



(function(_, $, xfalib){

    var LocalizationUtil = xfalib.ut.LocalizationUtil = xfalib.ut.Class.extend({

        getLocalizedMessage: function(category, message, snippets){
            var resolvedMessage = message;
            if(snippets){
                //resolve message with snippet
                resolvedMessage = resolvedMessage.replace(/{(\d+)}/g, function(match, number) {
                    return typeof snippets[number] != 'undefined'
                        ? snippets[number]
                        : match
                        ;
                });
            }
            var text = "";
            if (category) {
                text += " [" + category + "]";
            }
            text += "  " + resolvedMessage + "\r\n" ;
            return text;
        }

    });
})(_, $, xfalib);


/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2013 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/




(function(_, $, xfalib){
    xfalib.view.util.TextMetrics = {
        xfaUtil : xfalib.ut.XfaUtil.prototype,
        ERROR_MARGIN : 1,
        $measureEl : null,
        initialize : function(divEl){
            if(!divEl){
                var $div = $("<div></div>");
                $div.attr("id", "textMetrics");
                var divStyles = {};
                divStyles.left = -1000;
                divStyles.top = -1000;
                divStyles.position = "absolute";
                divStyles.visibility = "hidden";
                this.xfaUtil.$css($div.get(0), divStyles);
                this.$measureEl = $div;
                $("body").append(this.$measureEl);
            }else{
                this.$measureEl = divEl;
            }
        },

        measureExtent : function(text, options){
            text = text + " ";
            if(!this.$measureEl){
                this.initialize();
            }
            options = options || {};
            var textStyles = {};
            var $refEl =  $(options.refEl || "<div></div>") ;
            var refEl = $refEl.get(0);
            textStyles.fontSize = $refEl.css("fontSize") || options["font-size"] || options["fontSize"];
            textStyles.fontStyle = $refEl.css("fontStyle") || options["font-style"] || options["fontStyle"];
            textStyles.fontWeight = $refEl.css("fontWeight") || options["font-weight"] || options["fontWeight"];
            textStyles.fontFamily = $refEl.css("fontFamily") || options["font-family"] || options["fontFamily"];
            textStyles.lineHeight = refEl.style.lineHeight || options["line-height"] || options["lineHeight"];
            textStyles.letterSpacing = $refEl.css("letterSpacing") || options["letter-spacing"] || options["letterSpacing"];
            textStyles.whiteSpace =  $refEl.css("whiteSpace") || options["white-space"] || options["whiteSpace"] || "pre-wrap";
            if( $.browser.mozilla && $refEl.is("textarea"))      // for Bug #3621180
                textStyles.whiteSpace = "pre-wrap";
            textStyles.wordBreak =  $refEl.css("wordBreak") || options["word-break"] || options["wordBreak"] || "break-all";
            textStyles.wordWrap =  $refEl.css("wordWrap") || options["word-wrap"] || options["wordWrap"] || "break-word";
            textStyles.width = this._elWidth(refEl, options);
            textStyles.height = this._elHeight(refEl, options);
            textStyles.minWidth = this._elMinWidth(refEl, options);
            textStyles.minHeight = this._elMinHeight(refEl, options);
            textStyles.maxWidth = this._elMaxWidth(refEl, options);
            textStyles.maxHeight = this._elMaxHeight(refEl, options);
            this.xfaUtil.$css(this.$measureEl.get(0), textStyles);
            // for text fields/areas and draw requiring rich text support
            if(options.contentType === "text/html"){
              // retaining for future use . If we use the above property for other rich text
               if(options.skipXSSProtection) {
                 this.$measureEl.html(text);
               } else {
                 this.$measureEl.html(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(text));
               }
            }else {
               text = text.replace(/\n\r/g,"\n").replace(/\r\n/g,"\n").replace(/\r/g, "\n");
               this.$measureEl.text(text);
            }
            var measuredWidth =  this.$measureEl.width();
            var measuredHeight =  this.$measureEl.height();

            if(measuredWidth == Math.ceil(options["width"]) || measuredWidth == Math.floor(options["width"])){
                measuredWidth = options["width"];
            }
            /*
             FORMS-11363 : fix for height calculation of table cell
             Enable this toggle for old behaviour (if any regression comes)
             */
            else if ((window.FD && window.FD.isToggleEnabled("FT_FORMS-11363")) && (options["maxWidth"] > measuredWidth || (measuredWidth > options["minWidth"] > 0 && (options["maxWidth"] || -1) < 0))) {
                //complicated, please simplify if below hurts you:  Add error margin if there is scope of further extension of extent
                measuredWidth = measuredWidth + 1;
            } else if (options["maxWidth"] > measuredWidth || (measuredWidth > options["minWidth"] > 0 && (options["maxWidth"] || -1) < 0)) {
                //complicated, please simplify if below hurts you:  Add error margin if there is scope of further extension of extent
                measuredWidth = measuredWidth;
            }

            if(measuredHeight == Math.ceil(options["height"]) || measuredHeight == Math.floor(options["height"])){
                measuredHeight = options["height"];
            }
            else if( $refEl.is("textarea") && (options["maxHeight"] > measuredHeight || (measuredHeight > options["minHeight"] > 0 && (options["maxHeight"] || -1) < 0))){
                measuredHeight = measuredHeight +1;
            }
            this.$measureEl.empty();
            return {width : measuredWidth, height : measuredHeight};
        },

        _elWidth : function(refEl, options){
            if(options["minWidth"] && options["minWidth"] > -1)
                return "auto";
            else if(options["maxWidth"] && options["maxWidth"] > -1)
                return "auto";
            else
                return options["width"] || "auto";
        },

        _elHeight : function(refEl, options){
            // TODO: check for calculations here for floating field and other cases.
            if(options["contentType"] === "text/html")
                return "auto";
            if(options.isDraw) { // for handling the case of draw having floating fields
                return "auto";
            }
            if(!$(refEl).is("textarea"))
                return options["height"] || "auto";
            if(options["minHeight"] && options["minHeight"] > -1)
                return "auto";
            else if(options["maxHeight"] && options["maxHeight"] > -1)
                return "auto";
            else
                return options["height"] || "auto";
        },

        _elMinWidth : function(refEl, options){
            if(options["minWidth"] && options["minWidth"] > -1)
                return options["minWidth"];
            else
                return "0"; //default css value
        },

        _elMinHeight : function(refEl, options){
            if(options["minHeight"] && options["minHeight"] > -1)
                return options["minHeight"];
            else
                return "0"; //default css value
        },

        _elMaxWidth : function(refEl, options){
            if(options["maxWidth"] && options["maxWidth"] > -1)
                return options["maxWidth"];
            else
                return "none"; //default css value
        },

        _elMaxHeight : function(refEl, options){
            if(options["maxHeight"] && options["maxHeight"] > -1)
                return options["maxHeight"];
            else
                return "none"; //default css value
        },

        _destroy : function() {
            $("#textMetrics").remove();
            this.$measureEl = null;
        }
    }
})(_, $, xfalib);
(function($, _) {

	$.alertBox = {

		verticalOffset: -75,
		horizontalOffset: 0,
		repositionOnResize: true,
		overlayOpacity: 0.01,
		overlayColor: '#FFF',
		draggable: false,
		dialogClass: null,
		imageDirectory: "..",
		images: ["A_Warning_Lg_N.png", "A_Alert2_Lg_N.png", "C_QuestionBubble_Xl_N.png", "A_InfoBlue_32x32_N.png"],

		alert: function(img, message, title, callback) {
			this._show(img, title, message, null, 'OK', function(result) {
				if( callback ) callback(result);
			});
		},

		okCancel: function(img, message, title, callback) {
			this._show(img, title, message, null, 'OK-Cancel', function(result) {
				if( callback ) callback(result);
			});
		},
		yesNo: function(img, message, title, callback) {
			this._show(img, title, message, null, 'Yes-No', function(result) {
				if( callback ) callback(result);
			});
		},

		yesNoCancel: function(img, message, title, callback) {
			this._show(img, title, message, null, 'Yes-No-Cancel', function(result) {
				if( callback ) callback(result);
			});
		},

		_createBox: function(msgBox_message,buttons,callback) {
			var that = this;
			$("#"+msgBox_message).after("<div id='msgBox_panel'>");
			_.each(buttons.split("-"),function(val,i) {
                var dispval = xfalib.locale.Strings[val.toLowerCase()] ? xfalib.locale.Strings[val.toLowerCase()] : val;  // keys in loaclization files are in lower-case
                $("#msgBox_panel").append("<input type='button' value='"+dispval+"' id = 'msgBox_"+val+"' class=msgbox_input />");
				$("#msgBox_"+val).click( function() {
					that._hide();
					callback(!i);
				});
				if(!i) $("msgBox_"+val).focus();
			});
		},

		_show: function(img, title, msg, value, type, callback) {

			this._hide();
			this._overlay('show');

			$("BODY").append(
			  '<div id="msgBox_container">' +
			    '<h1 id="msgBox_title"></h1>' +
			    '<div id="msgBox_content">' +
			      '<div id="msgBox_message"></div>' +
				'</div>' +
			  '</div>');

			if( this.dialogClass ) $("#msgBox_container").addClass($.alertBox.dialogClass);

			$("#msgBox_container").css({
				position: 'absolute',
				zIndex: 99999,
				padding: 0,
				margin: 0
			});

			$("#msgBox_title").text(title);
			$("#msgBox_content").addClass("msgBoxType"+img);//css("background-image","url("+this.imageDirectory+ this.images[img]+")");
			msg = xfalib.ut.XfaUtil.prototype.encodeScriptableTags(msg.replace(/\n/g, '<br />'));
            $("#msgBox_message").html(msg);

			$("#msgBox_container").css({
				minWidth: $("#msgBox_container").outerWidth(),
				maxWidth: $("#msgBox_container").outerWidth()
			});

			this._reposition();
			this._maintainPosition(true);

			this._createBox("msgBox_message",type,callback);

			//TODO: Make keyboard input work
			/*$("#msgBox_ok").keypress( function(e) {
				if( e.keyCode == 13 || e.keyCode == 27 ) $("#msgBox_ok").trigger('click');
			});
			$("#msgBox_cancel").keypress( function(e) {
				if( e.keyCode == 13 ) $("#msgBox_ok").trigger('click');
				if( e.keyCode == 27 ) $("#msgBox_cancel").trigger('click');
			});
			$("#msgBox_yes, #msgBox_no").keypress( function(e) {
				if( e.keyCode == 13 ) $("#msgBox_yes").trigger('click');
					if( e.keyCode == 27 ) $("#msgBox_no").trigger('click');
				});*/

		},

		_hide: function() {
			$("#msgBox_container").remove();
			this._overlay('hide');
			this._maintainPosition(false);
		},

		_overlay: function(status) {
			switch( status ) {
				case 'show':
					this._overlay('hide');
					$("BODY").append('<div id="msgBox_overlay"></div>');
					$("#msgBox_overlay").css({
						position: 'absolute',
						zIndex: 99998,
						top: '0px',
						left: '0px',
						width: '100%',
						height: $(document).height(),
						background: this.overlayColor,
						opacity: this.overlayOpacity
					});
				break;
				case 'hide':
					$("#msgBox_overlay").remove();
				break;
			}
		},

		_reposition: function() {
            var windowHeight = $(window).height() / xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowWidth = $(window).width() / xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowScrollTop =  $(window).scrollTop() / xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowScrollLeft =  $(window).scrollLeft() / xfalib.ut.XfaUtil.prototype.formScaleFactor,
			    top = ((windowHeight / 2) - ($("#msgBox_container").outerHeight() / 2)) + this.verticalOffset,
			    left = ((windowWidth / 2) - ($("#msgBox_container").outerWidth() / 2)) + this.horizontalOffset;
			if( top < 0 ) top = 0;
			if( left < 0 ) left = 0;

			// IE6 fix
			if( $.browser.msie && parseInt($.browser.version) <= 6 ) top = top + windowScrollTop;

			$("#msgBox_container").css({
				top: top + windowScrollTop + 'px',
				left:  left + windowScrollLeft + 'px'
			});
			$("#msgBox_overlay").height( $(document).height() );
		},

		_maintainPosition: function(status) {
			if( this.repositionOnResize ) {
				switch(status) {
					case true:
						$(window).on('resize', this._reposition);
					break;
					case false:
						$(window).off('resize', this._reposition);
					break;
				}
			}
		}

	};
})($, window._);/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2016 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/


(function(_, $, xfalib){
    xfalib.view.util.HtmlUtil = {
        /*
        * Most of the time it returns undefined while accessing an undefined attribute of a dom element.
        * But some browsers can throw specific exceptions while accessing an attribute which is un-supported for a specific case.
        * This API is to make this behaviour consistent across browsers and return undefined for un-supported attributes.
        * */
        getHTMLSupportedAttr : function($domElement, attr){
           try{
               return $domElement[attr];
            }
           catch (err){
               return undefined;
            }
        },

        /**
         * Checks if the attribute is supported for the given HTML element.
         * This is primarily useful to support HTML5 features in widgets
         * @param element       name of HTML element
         * @param attribute     attribute to check on the element
         * @returns {boolean}
         */
        elementSupportsAttribute : function (element, attribute) {
            var test = document.createElement(element);
            if (attribute in test) {
                $(test).remove();
                test = null;
                return true;
            } else {
                $(test).remove();
                test = null;
                return false;
            }
        }
    }
})(_, $, xfalib);
/*************************************************************************
*
* ADOBE CONFIDENTIAL
* ___________________
*
*  Copyright 2013 Adobe Systems Incorporated
*  All Rights Reserved.
*
* NOTICE:  All information contained herein is, and remains
* the property of Adobe Systems Incorporated and its suppliers,
* if any.  The intellectual and technical concepts contained
* herein are proprietary to Adobe Systems Incorporated and its
* suppliers and are protected by trade secret or copyright law.
* Dissemination of this information or reproduction of this material
* is strictly forbidden unless prior written permission is obtained
* from Adobe Systems Incorporated.
**************************************************************************/



(function(_, $, xfalib){
    xfalib.view.util.Styles = {
        xfaUtil : xfalib.ut.XfaUtil.prototype,
        _deviceResolution :  144.0, //DPI
        _in2mmFactor : 25.4,
        _pdfResolution : 72.0 ,
        getStyleForEdge : function (edgeElement, str, cssStyleObj){
            var style = { "raised" : "outset" ,
                "dashDot" : "dashed" ,
                "dashDotDot" : "dashed" ,
                "dashed" : "dashed" ,
                "dotted" : "dotted" ,
                "embossed" : "groove" ,
                "etched" : "inset" ,
                "lowered" : "ridge",
                "solid" : "solid"};
            if(edgeElement && edgeElement.jsonModel.presence != "hidden" && edgeElement.jsonModel.presence !="invisible") {
                cssStyleObj['border'+str+'width'] = this._subPixelValue(this._convertToPx(edgeElement.getAttribute('thickness'))) || "1px";
                if(edgeElement.getElement("color") && edgeElement.getElement("color").getAttribute("value") !="")  {
                    var color =   edgeElement.getElement("color").getAttribute("value");
                    color = "rgb(" + color + ")";
                    cssStyleObj['border'+str+'color']   = color  ;
                }
                else {
                    cssStyleObj['border'+str+'color'] = "rgb(0,0,0)"  ;
                }
                cssStyleObj['border'+str+'style']   = style[edgeElement.getAttribute('stroke')] || "solid" ;
            } else {
                cssStyleObj['border'+str+'width'] =  "0px";
                return 1;
            }

        },

        getStyleForBorder : function (border) {
            if(border) {
                var edge  =  border.getElement('edge', 0, true),
                    edge1 = border.getElement('edge', 1, true),
                    edge2 = border.getElement('edge', 2, true),
                    edge3 = border.getElement('edge', 3, true);
                if(edge || edge1 || edge2 || edge3) {
                    var cssStyleObj = {} ;
                    var e0 = this.getStyleForEdge(edge, "-top-",cssStyleObj);
                    var e1 = this.getStyleForEdge(edge1 || edge,"-right-",cssStyleObj);
                    var e2 = this.getStyleForEdge(edge2|| edge,"-bottom-",cssStyleObj);
                    var e3 = this.getStyleForEdge(edge3 || edge,"-left-",cssStyleObj);
                    if(e0 !=1|| e1 !=1|| e2 !=1|| e3!=1)
                        return cssStyleObj ;
                }
            }
                return null;
        },

        _convertToPx : function(size){
            if(!size)
                return 0;
            size = "" + size;
            var pxSize = size;
            if(size.indexOf("in") >=0){
                pxSize = this._mm2px(parseFloat(size) * this._in2mmFactor);
            }
            else if(size.indexOf("mm") >=0){
                pxSize = this._mm2px(size);
            }
            else if(size.indexOf("cm") >=0){
                pxSize = this._mm2px(parseFloat(size) * 10);
            }
            else if(size.indexOf("pt") >=0){
                pxSize = parseFloat(size) * (this._deviceResolution/this._pdfResolution);
            }
            else if(size.indexOf("px") >=0){
                pxSize = parseFloat(size);
            }
            return pxSize;
        },

        _mm2px : function(mmSize){
            var mmSizeNum = 0;
            if(_.isNumber(mmSize))
                mmSizeNum = mmSize;
            else{
                mmSizeNum = parseFloat(mmSize)
            }
            var mm2in = 1/25.4 ;
            var pxSize = mmSizeNum*mm2in*this._deviceResolution;
            return pxSize;
        },

        _subPixelValue : function(value){
            if(value > 0.01)
                return Math.max(value, 1.0);
            else
                return value;
        }
    }
})(_, $, xfalib);
/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2017 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by all applicable intellectual property
 * laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/




(function(_, $, xfalib){
    xfalib.view.util.traversalManager = {

        // compute tabIndex for the provided page
        _computTabIndex : function (pageView) {
            var pageNum = pageView._pageNumber(),
                tabIndex = this._tabIndexBasedOnRange(pageNum);
            this.geographicalOrder = [];
            this._createGeographicalOrder(pageView);
            this._createFinalTraversalOrder(tabIndex); // assign tab index using traversal element and geographicalOrder
            // keep tracks of the last field on the page to get tab index so that handler to render next page can be added on getting focus through tabbing
            this._lastFieldTabbed = null;
        },

        _tabIndexBasedOnRange : function (pageNum) {
            var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]),
                tabIndexConfig = (behaviorConfig.isOn('mfRangeTabIndex')|| behaviorConfig.isOn('rangeTabIndex')),
                /*assuming single page can not have more than 1000 fields.[index -> 0 to 999]
                  this is also configurable by passing the maximum number of fields allowable in the page
                  in the config parameter */
                maxFieldInPageForTabIndex = tabIndexConfig? parseInt(tabIndexConfig):1000;

            return pageNum * maxFieldInPageForTabIndex;
        },

        // to create geographical order array which will be containing all the views in the geographical order
        _createGeographicalOrder : function (currentView) {
            var sortedChildViewWrapper = this._sortViewGeographically(currentView.childViews);
            _.each(sortedChildViewWrapper, function (wrapper) {
                var currentView = wrapper.view,
                    instanceCheckMap = this._getMapOfInstanceCheck(currentView),
                    isViewEligibleForTabbing = this._isViewEligibleForTabbing(currentView);
                //  If the child view is fieldView, drawView, exclGroupView or subformView then we will push these views in this.geographicalOrder array,
                //  as we need their traverse object during final traversing
                if (((instanceCheckMap.isField && !instanceCheckMap.isChildOfExclGroup) || instanceCheckMap.isSubform || instanceCheckMap.isDraw
                    || instanceCheckMap.isExclGroup) && isViewEligibleForTabbing) {
                    this.geographicalOrder.push({
                        view : currentView,
                        visited : false
                    });
                }
                if (instanceCheckMap.isContainer && isViewEligibleForTabbing) {
                    this._createGeographicalOrder(currentView);
                }
            }, this);
        },

        // to sort provided views in geographical order
        _sortViewGeographically : function (views) {
            var viewsWrapper = [];   // wrapper of view and their geographical reference
            _.each(views, function(view) {
                var position = view.$el.offset(),
                    paddedX = xfalib.ut.XfaUtil.prototype.padString(parseInt(position.left), 5, '0'),
                    marginTop = view._marginTop(),
                    paddedY = position.top - parseFloat(marginTop),
                    positionalReference = parseInt("" + parseInt(paddedY) + paddedX);
                viewsWrapper.push({
                    positionalReference: positionalReference,
                    view: view
                });
            });
            return _.sortBy(viewsWrapper, function(viewWrapper){ return viewWrapper.positionalReference; });
        },

        // Walk through views in geographical order and assign tab index honouring traversal object if present
        _createFinalTraversalOrder : function (tabIndex) {
            var geographicalOrderLength = this.geographicalOrder.length,
                currentWrappedObj = null,
                index = -1,
                traversalIndex = 0,  // index of the element to be traversed
                viewTraversed = 0;  // counter of view traversed

            while (1) {
                if (traversalIndex >= geographicalOrderLength) {
                    traversalIndex = 0;
                }
                currentWrappedObj = this.geographicalOrder[traversalIndex];

                if (!currentWrappedObj || currentWrappedObj.visited) {  // if the wrapped object does not exist or it has been visited move to the next one
                    traversalIndex++;
                } else {
                    currentWrappedObj.visited = true;
                    viewTraversed++;
                    var currentView = currentWrappedObj.view,
                        instanceCheckMap = this._getMapOfInstanceCheck(currentView),
                        currentModel = currentView.model,
                        nextView = null,
                        nextViewSom = null;

                    // get the first traversal of the subform if traversal object is present, else move to the next geographical element
                    // next of the subform will be taken care when we will be finding the next view to be traversed,
                    // as we will be checking if the ancestor contain next before moving to geographically next view
                    if (instanceCheckMap.isSubform) {
                        if (currentModel && currentModel.getTraversalObject()) {
                            // get the first element to be traversed and update traversalIndex
                            nextViewSom = currentModel.getNextTraversalSom(xfalib.template.Constants.firstTraversal);
                            index = this._findViewInGeographicalOrderArray(nextViewSom);
                            traversalIndex = index != -1 ? index : traversalIndex + 1;
                        } else {
                            traversalIndex++;
                        }
                    // get the next traversal for the field/draw if traversal object is present, else move to the next geographical element
                    // update the tabindex for the field
                    } else if (instanceCheckMap.isField || instanceCheckMap.isDraw) {
                        if (instanceCheckMap.isField) {
                            currentView.updateTabIndex(tabIndex);
                            this._lastFieldTabbed = currentView;
                            tabIndex++;
                        }
                        if (currentModel && currentModel.getTraversalObject()) {
                            //get next element to be traversed and update traversalIndex
                            nextViewSom = currentModel.getNextTraversalSom(xfalib.template.Constants.nextTraversal);
                            index = this._findViewInGeographicalOrderArray(nextViewSom);
                            traversalIndex = index != -1 ? index : traversalIndex + 1;
                        } else {
                            traversalIndex = this._findNextViewToBeTraversed(traversalIndex);
                        }
                    // if traversal object present get the next element to be traversed, if first is also present then update tab index of the first element
                    // else look for the traversal element in the children
                    } else if (instanceCheckMap.isExclGroup) {
                        if (currentModel && currentModel.getTraversalObject()) {
                            // get next element to be traversed and update traversalIndex
                            nextViewSom = currentModel.getNextTraversalSom(xfalib.template.Constants.nextTraversal);
                            index = this._findViewInGeographicalOrderArray(nextViewSom);
                            traversalIndex = index != -1 ? index : traversalIndex + 1;
                            // if first is also present assign tab index to that referred child else assign same tab index to all child
                            nextViewSom = currentModel.getNextTraversalSom(xfalib.template.Constants.firstTraversal);
                            tabIndex = this._updateTabIndexOfExclGroupChildren(currentView, tabIndex, nextViewSom);
                        } else {
                            tabIndex = this._updateTabIndexOfExclGroupChildren(currentView, tabIndex);
                            traversalIndex = this._findTraversalInExclGroupChildren(currentView, traversalIndex);
                        }
                    } else {
                        traversalIndex++;
                    }
                }

                // if all the view are traversed, we have assigned tab index to all the views
                if (viewTraversed >= geographicalOrderLength) {
                    this._renderNextPageFuture();
                    break;
                }
            }
        },

        // Check if the nextView is a sibling of the currentView (shares the same parent)
        // if it is not a sibling, check if the parent has a NEXT traversal.
        // if so get the node traversed to else recurse to see if nextView is a sibling of our parent
        // return -1 if the provided next node is sibling of current node or if no ancestor contain next traversal
        // else return index of the next traversal object of parent
        _getParentNextTraversal : function (currentView, nextView, traversalIndex) {
            var parentView = currentView.parentView,
                parentModel = parentView.model,
                nextViewParentModel = nextView.parentView.model,
                traversalObj = null,
                nextIndex = -1;

            if (parentModel && nextViewParentModel && parentModel.somExpression != nextViewParentModel.somExpression) {
                if(parentView && parentView instanceof xfalib.view.SubformView) {
                    if (parentModel.getTraversalObject()) {
                        var nextViewSom = parentModel.getNextTraversalSom(xfalib.template.Constants.nextTraversal);
                        nextIndex = this._findViewInGeographicalOrderArray(nextViewSom);
                        if (nextIndex != -1 && !this.geographicalOrder[nextIndex].visited) {
                            return nextIndex;
                        } else {
                            return traversalIndex++;
                        }
                    } else {
                        this._getParentNextTraversal(parentView, nextView, traversalIndex);
                    }
                } else {  // parentView is not a subform so skip up a level and re-check sibling
                    this._getParentNextTraversal(parentView, nextView, traversalIndex);
                }
            } else {
                return -1;  //provided currentView and nextView are sibling
            }
            return traversalIndex++;
        },

        // return the index of the view having provided somExpression in the geographicalOrder array
        _findViewInGeographicalOrderArray : function (somExpression) {
            return _.findIndex(this.geographicalOrder, function (viewWrapper) {
                var currentViewModel = viewWrapper.view.model;
                return (currentViewModel && currentViewModel.somExpression == somExpression);
            });
        },

        // find the next element to be traversed based on the provided traversalIndex
        _findNextViewToBeTraversed : function (traversalIndex) {
            var currentView = this.geographicalOrder[traversalIndex].view,
                index = this._getNextUnvisited(traversalIndex),   //get next unvisited based on geographical location
                nextView = null,
                nextIndex = -1;

            if (index != -1) {
                nextView = this.geographicalOrder[index].view;
                //check if both are sibling and if not find the next of the parent and update traversalIndex
                nextIndex = this._getParentNextTraversal(currentView, nextView, traversalIndex);
                return nextIndex != -1 ? nextIndex : index;
            }
            return traversalIndex++;
        },

        // return the next unvisited node based on geographical location
        // starting from the traversalIndex and wraps around to check all the views
        _getNextUnvisited : function (traversalIndex) {
            var geographicalOrderLength = this.geographicalOrder.length,
                index = 0,
                actualIndex = 0;
            while(index < geographicalOrderLength) {
                actualIndex = (index + traversalIndex) % geographicalOrderLength;
                if(!this.geographicalOrder[actualIndex].visited) {
                    return actualIndex;
                }
                index++;
            }
            return -1;
        },

        // assign same tab index to all the child of exclude group
        // if exclude group contain first traverse object, then the child being referred as first should have less tabindex
        // compared to other child
        _updateTabIndexOfExclGroupChildren : function (exclGroupView, tabIndex, firstChildSom) {
            _.each(exclGroupView.childViews, function(child){
                if (this._isViewEligibleForTabbing(child)) {
                    if(firstChildSom && child.model.somExpression == firstChildSom) {
                        tabIndex++;
                        child.updateTabIndex(tabIndex-1);
                        this._lastFieldTabbed = child;
                    } else {
                        child.updateTabIndex(tabIndex);
                    }
                }
            }, this);
            if (!firstChildSom) {
                this._lastFieldTabbed = exclGroupView.childViews[0];
            }
            return ++tabIndex;
        },

        // find if any child contains next pointer and update traversal index
        // start with the last in the geographical order of the children and find child which have next traversal
        _findTraversalInExclGroupChildren : function (exclGroupView, traversalIndex) {
            var sortedChildView = this._sortViewGeographically(exclGroupView.childViews),
                tempObj = null,
                childView = null,
                childModel = null,
                traversalObj = null,
                nextViewSom = null,
                index = -1;

            sortedChildView.reverse();
            tempObj = _.find(sortedChildView, function(child) {
                childView = child.view;
                childModel = childView.model;
                if(childModel && (traversalObj = childModel.getTraversalObject())) {
                    return traversalObj.length > 0;
                }
            });

            if (tempObj) {
                nextViewSom = tempObj.model.getNextTraversalSom(xfalib.template.Constants.nextTraversal);
                index = this._findViewInGeographicalOrderArray(nextViewSom);
                traversalIndex = index != -1 ? index : traversalIndex + 1;
            } else { // else get next unvisited based on geographical location
                traversalIndex = this._findNextViewToBeTraversed(traversalIndex);
            }
            return traversalIndex;
        },

        // check if the view is initialized and visible
        _isViewEligibleForTabbing : function (view) {
            if (view._initialized && view.$el.css("visibility") != "hidden") {
                return true;
            }
            return false;
        },

        // return map of whethter provided view is instance of the various views
        _getMapOfInstanceCheck : function (view) {
            var instanceCheckMap = {};
            instanceCheckMap.isSubform = view instanceof xfalib.view.SubformView;
            instanceCheckMap.isField = view instanceof xfalib.view.FieldView;
            instanceCheckMap.isDraw = view instanceof xfalib.view.XfaDrawView;
            instanceCheckMap.isExclGroup = view instanceof xfalib.view.ExclGroupView;
            instanceCheckMap.isChildOfExclGroup = view.parentView instanceof xfalib.view.ExclGroupView;
            instanceCheckMap.isContainer = view instanceof xfalib.view.ContainerView;

            return instanceCheckMap;
        },

        // add event handler for rendering next page on tabbing on last field of the page
        _renderNextPageFuture : function () {
            if (this._lastFieldTabbed) {
                this._lastFieldTabbed.$el.one('focusin.traversalManager', function() {
                    var pagingManager = window.formBridge ? window.formBridge.pagingManager() : null;
                    $(window).on( "keyup.traversalManager", function (e) {
                        var code = (e.keyCode ? e.keyCode : e.which);
                        if (code == 9 && pagingManager && pagingManager.hasMorePages()) {
                            pagingManager.renderNextPage();
                            $(window).off("keyup.traversalManager");
                        }
                    });
                });
            }
        },
        _destroy : function() {
            this.geographicalOrder = null;
        }
    }
})(_, $, xfalib);
/*************************************************************************
*
* ADOBE CONFIDENTIAL
* ___________________
*
*  Copyright 2013 Adobe Systems Incorporated
*  All Rights Reserved.
*
* NOTICE:  All information contained herein is, and remains
* the property of Adobe Systems Incorporated and its suppliers,
* if any.  The intellectual and technical concepts contained
* herein are proprietary to Adobe Systems Incorporated and its
* suppliers and are protected by trade secret or copyright law.
* Dissemination of this information or reproduction of this material
* is strictly forbidden unless prior written permission is obtained
* from Adobe Systems Incorporated.
**************************************************************************/



(function(_, $, xfalib){

    var ErrorManager = xfalib.view.util.ErrorManager = xfalib.ut.Class.extend({

        options: {
            warningMessageVisible:false,
            errorMessageVisible: false
        },

        initialize: function () {
            $(window).on("destroy.xfa", function () {
                $("#error-msg").hide();
                $("#warning-msg").hide();
            });
        },

        onFieldEnter: function (jqWidget) {
            var element = jqWidget.element;
            if (jqWidget.option("errorMessage")|| jqWidget.option("warningMessage")) {
                var pos = $(element).offset(),
                    styles = {};
                styles.left = (pos.left * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) + element.width() + 5) + "px";
                styles.top = pos.top * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) + "px";
                if (jqWidget.option("errorMessage")) {
                    jqWidget.$css($("#error-msg").get(0), styles);
                    $("#error-msg").text(jqWidget.option("errorMessage")).show();
                    jqWidget.option("errorMessageVisible",true);
                }
                else if (jqWidget.option("warningMessage")) {
                    jqWidget.$css($("#warning-msg").get(0), styles);
                    $("#warning-msg").text(jqWidget.option("warningMessage")).show();
                    jqWidget.option("warningMessageVisible",true);
                }
            }
        },

        onFieldExit: function (jqWidget) {
            if (jqWidget.option("errorMessageVisible")) {
                $("#error-msg").hide();
                jqWidget.option("errorMessageVisible",false);
            } else if (jqWidget.option("warningMessageVisible")) {
                $("#warning-msg").hide();
                jqWidget.option("warningMessageVisible",false);
            }
        },

        markError: function (jqWidget, msg, type) {
            // assigning role="alert" so that JAWS reads-out the validation message
            if (type != "warning") {
                if ($("#error-msg").length < 1)
                    $("<div id='error-msg' role='alert'></div>").appendTo('body');
                jqWidget.option("errorMessage",msg);
                jqWidget.element.addClass("dataInvalid");
            } else {
                if ($("#warning-msg").length < 1)
                    $("<div id='warning-msg' role='alert'></div>").appendTo('body');
                jqWidget.option("warningMessage",msg);
            }

        },

        clearError: function (jqWidget) {
            this.onFieldExit(jqWidget);
            jqWidget.element.removeClass("dataInvalid");
            jqWidget.option("errorMessage",null);
            jqWidget.option("warningMessage",null);
        }
    });
})(_, $, xfalib);
(function(_,$, xfalib) {
    var xfaUtil = xfalib.ut.XfaUtil.prototype,
        BUFFER_SPC = 20;

    /* template for the clear Button */
    var clearButtonTemplate = '<div class="dp-clear">' +
        '<a></a>' +
        '</div>';

    /* template for the calendar
    * header contains the navigation icons (left and right arrows)
    * and the current caption (which can be date, year or month)
    *
    * monthview displays the grid for showing the dates for a particular
    * month
    *
    * yearview displays all the months of that year
    *
    * yearsetview displays a grid of 16 years. This can be configured
    * through the option: yearsPerView
    *
    */
    var calendarTemplate = '<div class="dp-header">' +
        '<div class="dp-leftnav"></div>' +
        '<div class="dp-caption"></div>' +
        '<div class="dp-rightnav"></div>' +
        '</div>' +
        '<div role="table" class="view dp-monthview"></div>' +
        '<div role="table" class="view dp-yearview"></div>' +
        '<div role="table" class="view dp-yearsetview"></div>';

    /*template for the timer: not implemented yet */
    var watchTemplate = '<div class="dp-header">' +
        '<div class="dp-leftnav"></div>' +
        '<div class="dp-caption"></div>' +
        '<div class="dp-rightnav"></div>' +
        '</div>' +
        '<div class="view dp-monthview"></div>' +
        '<div class="view dp-yearview"></div>' +
        '<div class="view dp-yearsetview"></div>';

    /** default configuration options
     *
     * container: the html element where the datepicker template will be added
     *
     * yearsPerView: number of years to show in the yearset view
     *
     * width: with of the widget
     *
     * viewHeight: Height of the month,year and yearset view. This doesn't include
     *             the height of the header
     *
     * locale: locale information for the locale in which to show the datepicker which comprises of
     *        days: day names to display in the monthview
     *        months: month names to display in the yearview
     *        zero: string representation of zero in the locale. Numbers will be
     *              displayed in that locale only
     *        clearText: Text to display for the reset button
     *        name: name of the locale
     *
     * format: input format for the datepicker (not implemented)
     *
     * pickerType: type of the datetimepicker (date, datetime and time)
     *
     * positioning: element around which datepicker will be displayed. if null then it
     *              will be displayed around the input element
     *
     * showCalendarIcon: to show the Calendar on the right of the text field or not
     */

    var defaults = {
        container: "body",
        yearsPerView: 16,
        width: 340,
        viewHeight: 248,
        locale: {
            days:["S","M","T","W","T","F","S"],
            months: ["January","February","March","April","May","June","July","August","September","October","November","December"],
            zero: "0",
            clearText: "Clear",
            name:"en_US"
        },
        format:"YYYY-MM-DD",
        pickerType:"date",
        positioning: null,
        showCalendarIcon: false
    },
    dates = [31,28,31,30,31,30,31,31,30,31,30,31],
    /*
     *  Actions to perform when clicked on the datepicker buttons
     *  for different views
     *  caption: view to show when clicked on caption
     *           (Year/YearSet/Month/null) null means don't change the view
     *  li: view to show when clicked on date, month or year element
     *  upDown: add(up key) or subtract(down key) current date (for monthview),
     *          month(Year View) or year(YearSetView) with the number provided
     *  key: identifies the key that needs to be changed for that view
     */
    viewAction = {
        Month: {
            caption: 'Year',
            li: null,
            key:"day",
            upDown:7
        },
        Year: {
            caption: "Yearset",
            li: "Month",
            key:"month",
            upDown:3
        },
        Yearset: {
            caption: null,
            li: "Year",
            key:"year",
            upDown:4
        }
    },
    headerClass = "header",

    DateTimePicker = function() {
        this.initialized = false;
    }

    $.extend(DateTimePicker.prototype, {
        /*
         * create the widget using the provided options
         */
        create: function(options) {
            var $dp,self = this,html="",prevNavWidth,nextNavWidth;
            if (window.FD && window.FD.isToggleEnabled("FT_FORMS-13599")) {
                    defaults.width = 433;
                }
            this.options = $.extend({},defaults,options);
            // prevent memory leak since options.positioning holds reference to HTML DOM
            this.options.positioning = null;
            // If width of date-picker exceeds screen width then it'll take up the entire screen width in AF
            if(window.guideBridge && this.options.width > window.innerWidth && window.innerWidth > 0) {
               this.options.width=window.innerWidth - BUFFER_SPC; // buffer
            }
            if(this.options.pickerType.match(/date/)) {
                html += calendarTemplate;
            }

            if(this.options.pickerType.match(/time/)) {
                html += watchTemplate;
            }

            html += clearButtonTemplate;

            $.extend(this, {
                selectedDay:0,
                selectedMonth:0,
                selectedYear:0,
                currentDay:0,
                currentMonth:0,
                currentYear:0,
                touchSupported : xfalib.ut.TouchUtil.TOUCH_ENABLED,
                _visible:false,
                _defaultView:"Month",
                _keysEnabled:false,
                focusedOnDatepickerItem : false,
                keyboardAccessibility : true,
                $dp:$("<div></div>").addClass("datetimepicker")
                                    .width(this.options.width)
                                    .append(html)
                                    .addClass("datePickerTarget")
                                    .appendTo(this.options.container)
                                    .toggleClass("datetimepicker-notouch",this.touchSupported),
                $month: $(".dp-monthview",this.$dp).height(this.options.viewHeight),
                $year: $(".dp-yearview",this.$dp).height(this.options.viewHeight),
                $yearset : $(".dp-yearsetview",this.$dp).height(this.options.viewHeight)
            });
            this.actualWidth = Math.floor(this.$dp.width());
            this.$clear = $('.dp-clear a', this.$dp).on("click", $.proxy(this._clearDate, this));
            this.$prevNavWidthBtn = $(".dp-leftnav", this.$dp).on("click",
                                                            function(evnt) {
                                                                self._adjustDate(-1, self.view, false)
                                                            });
            this.$nextNavWidthBtn = $(".dp-rightnav", this.$dp).on("click",
                                                            function(evnt) {
                                                                self._adjustDate(1, self.view, false)
                                                            });
            prevNavWidth = this.$prevNavWidthBtn.outerWidth(true);
            nextNavWidth = this.$nextNavWidthBtn.outerWidth(true);
            this.$caption = $(".dp-caption", this.$dp).width(this.actualWidth - prevNavWidth - nextNavWidth)
                                                     .on("click",
                                                            function(evnt) {
                                                                if(!self.$caption.hasClass("disabled")) {
                                                                    self._layout(viewAction[self.view].caption);
                                                                }
                                                      });
            if (this.keyboardAccessibility) {
                _.each([this.$prevNavWidthBtn, this.$caption, this.$nextNavWidthBtn, this.$clear], function (elem, i) {
                    elem.attr("tabIndex", i + 1);
                });
            }
            // attach click event on entire datePicker popup
            $(this.$dp).on("click",
                function(evnt) {
                    //focus only if the device doesn't support touch
                    // input otherwise on screen keyboard will popup
                    if(!self.touchSupported)
                        self._curInstance.$field.focus();
                });

            $(window).on("touchstart.datetimepicker mousedown.datetimepicker",self._checkWindowClicked);
            this._curInstance = null;
        },

        /*
         * attaches the date picker to the field. This is a one time operation
         * First creates a configuration object and stores it in the field data attributes
         * then attaches event handlers on click, focus (to show the picker) and blur (to hide) events
         */
        _attachField: function($field,options, value) {
            var inst = this._newInst($field,options, value),
                self = this,
                activateField = function(evnt) {
                    var data = xfaUtil.$data(evnt.target,"datetimepicker");
                    if(self._isFieldDisabled(data)) {
                        return;
                    }
                    if(!self._curInstance)
                         self._activateField(evnt);

                    if(self.options.showCalendarIcon) {
                        if (evnt.type === self.getEvent()) {
                            if (self._iconClicked) {
                                self._iconClicked = false;
                                if (self._visible) {
                                    self._hide(); // hide the calendar popup if visible when calendar icon is clicked
                                    self._curInstance.$field.focus(); // bring back focus in field
                                } else {
                                    self._show(); //// show the calendar popup if not visible when calendar icon is clicked
                                }
                            }
                        }
                    } else {
                        /*show the popup only if
                         1. click/touch event
                         2. focus event in case of non-touch devices and focus is not done using script
                         */
                        if (evnt.type === self.getEvent() || (evnt.type === "focus" && !self.touchSupported && !self.scriptFocus)) {
                            self._show(evnt);
                        }
                    }

                    self._clickedWindow = true;
                    self.scriptFocus = false;
                },
                deactivateField = function(evnt) {
                    //deactivate only if clicked outside window
                    // on touch devices only keyboard or calander should be active at once, touching keyboard should deactivate calendar
                    if ((self._clickedWindow && !self.focusedOnDatepickerItem) && (self.options.showCalendarIcon || !self.touchSupported)) {
                        self._hide();
                        self._deactivateField();
                        self._clickedWindow = true;
                    }
                };

            xfaUtil.$data($field[0],"datetimepicker",inst);

            $field.on(this.getEvent(),activateField)
                  .focus(activateField)
                  .blur(deactivateField);
            if(options.showCalendarIcon) {
                var calendarIcon = $("<div></div>")
                                    .addClass("datepicker-calendar-icon")
                                    .css({
                                        "width": options.iconWidth + "px",
                                        "height": options.iconHeight + "px"
                                    });
                calendarIcon.insertAfter($field);

                if (this.keyboardAccessibility) {
                    calendarIcon.attr("tabindex", 0);
                }

                calendarIcon.on(this.getEvent(), function (evnt) {
                                self._iconClicked = true;
                                $field.click();
                              })
                              .on("keydown", function (event) {
                                    if (event.keyCode === 32 || event.keyCode === 13) {
                                        // Check if field is disabled before triggering click
                                        var data = xfaUtil.$data($field[0], "datetimepicker");
                                        if (data && !self._isFieldDisabled(data)) {
                                            $field.click();
                                        }
                                    }
                              });
            }
        },

        _newInst: function($f,options, value) {
            return {
                $field:$f,
                locale: options.locale,
                positioning: options.positioning || $f,
                access:options.access,
                selectedDate:options.value,
                editValue :options.editValue,
                minValidDate : options.minValidDate,
                maxValidDate : options.maxValidDate,
                exclMinDate :  options.exclMinDate,
                exclMaxDate : options.exclMaxDate
            }
        },

        /*
         * To check where the click happened, if happened outside the datepicker
         * then hide the picker. This is checked whether any ancestor of clicked target
         * has a class datePickerTarget. This class is added to the attached element as well
         */
        _checkWindowClicked : function(evnt) {
            var self = adobeDateTimePicker;
            if(self._curInstance) {
                // datepickerTarget class depicts that the component is a part of the Date Field
                // and on click of that class, we should not hide the datepicker or fire exit events.
                if(!$(evnt.target).closest(".datePickerTarget").length) {
                    //non-touch devices do not deactivate on blur. Hence needs to be done here
                    if(self.touchSupported) {
                        self._hide()
                        //clicking outside a field doesn't blur the field in IPad. Doing it by script
                        self._curInstance.$field[0].blur()
                        self._deactivateField()
                    } else{
                        self._clickedWindow = true;
                        // set focusedOnDatepickerItem to false, it hides the datepicker see method deactivateField.
                        self.focusedOnDatepickerItem = false;
                        self._curInstance.$field.blur()
                    }
                }
                else {
                    self._clickedWindow = false;
                }
            }
        },

        /**
         * Checks if the current datepicker field is disabled.
         *
         * Fields marked as "readOnly" or with access set to false are considered
         * disabled and should not allow datepicker interaction.
         *
         * @param {Object} [data] - Optional data object to check. If not provided, uses current instance.
         * @returns {boolean} True if the field is disabled (access is "readOnly" or false), false otherwise.
         *                   Returns false if no current instance exists.
         */
        _isFieldDisabled: function(data) {
            if (data) {
                return data.access === false || data.access === "readOnly";
            }
            return this._curInstance && (this._curInstance.access === false || this._curInstance.access === "readOnly");
        },

        /*
         * handling of key strokes. All the key strokes prevent the default browser action
         * unless specified otherwise
         * tab: set focus on calendar icon when dateinput field is active, navigates through date picker buttons when datepicker is open,
         * otherwise perform default browser action
         * escape: hides the datepicker
         * down arrow key: navigate the picker downwards by the number specified in actionView.upDown of the current View
         * up arrow key: navigate the picker upwards by the number specified in actionView.upDown of the current View
         * left arrow key: navigate the picker one unit of that view backward
         * right arrow key: navigate the picker one unit of that view forward
         * shift + up: perform the action that happens on clicking the caption (as specified in actionView.caption)
         * shift + left: perform the action that happens on clicking the left navigation button
         * shift + right: perform the action that happens on clicking the right navigation button
         * space/enter: triggers the click event for the current focused element from datepicker/ opens datepicker when calendar icon is focused.
         */
        _hotKeys: function(evnt) {
            var handled = false, date;
            switch(evnt.keyCode) {
                case 9: //tab
                    // CQ-4239352 : Setting clickedWindow property to true on tabbing so that deactivateField logic gets executed
                    // When clicking on "x" on input field in in IE and when selecting the content and releasing the mouse select outside the field
                    // the click event is not trigerred on the field and hence activateField is not executed, so clickedWindow remains as false
                    adobeDateTimePicker._clickedWindow = true;
                    handled = false;
                    break;
                case 27://escape
                    if(this._visible) {
                        adobeDateTimePicker._hide();
                        this._curInstance.$field.focus();
                        handled = true;
                    }
                    break;
                case 32: //space
                case 13: // enter
                    if($(evnt.target).hasClass("datepicker-calendar-icon")){
                        // Check if field is disabled before showing datepicker
                        // disabled fields are marked as readOnly in the form
                        if(this._isFieldDisabled()) {
                            return;
                        }
                        if(!this._visible) {
                            this._show();
                            return;
                        }
                        this.$focusedDate.addClass("dp-focus");
                    }
                    break;
                case 40: //down arrow key
                    if(!this._visible) {
                        // Check if field is disabled before showing datepicker
                        if(this._isFieldDisabled()) {
                            return;
                        }
                        this._show();
                        return;
                    }
                    this.$focusedDate.addClass("dp-focus");
                    break;
            }

            if(adobeDateTimePicker._visible && this._keysEnabled) {
                var v = viewAction[this.view].key,
                    updown=viewAction[this.view].upDown;
                switch(evnt.keyCode) {
                    case 9: // tab
                        if (evnt.shiftKey) {
                            if ($(evnt.target).hasClass("dp-leftnav") || $(evnt.target).hasClass("dp-focus")) {
                                this._hide();
                                this._curInstance.$field.focus();
                                handled = true;
                            } else {
                                handled = false;
                            }
                        } else {
                            var buttonTabindex = $(evnt.target).attr("tabindex");
                            if (buttonTabindex === '0') {
                                if (evnt.target.tagName.toLocaleLowerCase() === "input") {
                                    this._hide();
                                    handled = false;
                                } else {
                                    this.$prevNavWidthBtn.focus();
                                    handled = true;
                                }
                            } else if (buttonTabindex === '4') {
                                this._hide();
                                this._curInstance.$field.focus();
                                handled = true;
                            } else {
                                handled = false;
                            }
                        }
                        break;
                    case 32: //select on space
                    case 13: // select on enter
                        this.hotKeyPressed = true;
                        this.focusedOnDatepickerItem = false;
                        if (!this.focusedOnDatepickerItem) {
                            $(evnt.target, this.$dp).triggerHandler("click");
                        } else {
                            if (this.$focusedDate) {
                                this.$focusedDate.trigger("click");
                            }
                        }
                        this.hotKeyPressed = false;
                        handled = true;
                        break;
                    case 37: //left arrow key
                        if (evnt.shiftKey) {
                            $(".dp-leftnav", this.$dp).triggerHandler("click");
                        } else {
                            this._adjustDate(-1, v, true);
                        }
                        handled = true;
                        break;
                    case 38: //up arrow key
                        if (evnt.shiftKey) {
                            this.$caption.triggerHandler("click");
                        } else {
                            this._adjustDate(-updown, v, true);
                        }
                        handled = true;
                        break;
                    case 39: //right arrow key
                        if (evnt.shiftKey) {
                            $(".dp-rightnav", this.$dp).triggerHandler("click");
                        } else {
                            this._adjustDate(+1, v, true);
                        }
                        handled = true;
                        break;
                    case 40: //down arrow key
                        this._adjustDate(updown, v, true);
                        handled = true;
                        break;
                    default:
                }
            }
            if(handled) {
                evnt.preventDefault();
            }
        },

        /*
         * show the datepicker.
         */
        _show: function() {
            if(this._isFieldDisabled())
                return;
            this.options.locale = this._curInstance.locale;
            if(!this._visible) {
                var self = this,
                    date = new Date(),
                    val,
                    maxDateInfo,
                    minDateInfo,
                    validDate;
                //Bug#3607735:
                // Date constructor in ipad 5.1 doesn't support "YYYY-MM-DD", hence parsing the date on our own
                validDate = xfalib.ut.DateInfo.ParseIsoString(this._curInstance.selectedDate);
                date = (validDate != null)? validDate.getDate(): new Date();
                this.selectedDay = this.currentDay = date.getDate();
                this.selectedMonth = this.currentMonth = date.getMonth();
                this.selectedYear = this.currentYear = date.getFullYear();
                maxDateInfo = this.options.maxValidDate ? xfalib.ut.DateInfo.ParseIsoString(this._curInstance.maxValidDate) : null;
                this.maxValidDate = maxDateInfo ? maxDateInfo.getDate() : null;
                minDateInfo = this.options.minValidDate ? xfalib.ut.DateInfo.ParseIsoString(this._curInstance.minValidDate) : null;
                this.minValidDate = minDateInfo ? minDateInfo.getDate() : null;
                this.exclMaxDate = this._curInstance.exclMaxDate;
                this.exclMinDate = this._curInstance.exclMinDate;
                $('.dp-clear a',this.$dp).text(this.options.locale.clearText);
                this._layout('Month');
                this._position();
                this.$dp.show();
                // if li element of datepicker is focused then set focusedOnDatepickerItem to true, it manages the visibility of the datepicker.
                this.focusedOnDatepickerItem = false;
                this._visible = true;
                if (this.options.showCalendarIcon) {
                    this._curInstance.$field.attr('readonly', true);    // when the datepicker is active, deactivate the field
                }
            }

            //   Disabling the focus on ipad  due to a bug where value of
            // date picker is not being set
            // Removing this code will only hamper one use case
            // where on ipad if you click on the calander then
            // the field becomes read only so
            // there is no indication where the current focus is
            // And  if you remove this foucs code all together
            // then what happens is that on desktop MF in iframe the exit event
            // is not getting called hence calander getting remained open even
            // when you click somewhere on window or focus into some other field
            if (this.options.showCalendarIcon  && !this.touchSupported) {
                if(this.$focusedDate.length > 0) {
                    this.$focusedDate.focus();  // shift focus on current date or selected date.
                } else {
                    this._curInstance.$field.focus(); // field loses focus after being marked readonly, causing blur event not to be fired later
                }
            }
        },

        /*
         * position the datepicker around the positioning element
         * provided in the options
         */
        _position: function() {
            var $elem = this._curInstance.positioning,
                windowScrollX = window.scrollX/ xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowScrollY = window.scrollY/ xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowInnerHeight = window.innerHeight/ xfalib.ut.XfaUtil.prototype.formScaleFactor,
                windowInnerWidth = window.innerWidth/ xfalib.ut.XfaUtil.prototype.formScaleFactor,
                height = $elem.outerHeight(true),
                width  = $elem.outerWidth(true),
                top = $elem.offset().top / xfalib.ut.XfaUtil.prototype.formScaleFactor + height,
                left = $elem.offset().left / xfalib.ut.XfaUtil.prototype.formScaleFactor,
                styles = {"top": (top+"px"), "left": (left+"px")},
                diffBottom = top + this.$dp.outerHeight(true) - windowInnerHeight - windowScrollY,
                newLeft,
                newTop;
            if(diffBottom > 0) {
                //can't appear at the bottom
                //check top
                newTop = top - height - this.$dp.outerHeight(true) - BUFFER_SPC;
                if(newTop < windowScrollY) {
                    //can't appear at the top as well ... the datePicker pop up overlaps the date field
                    newTop = top - diffBottom;
                    // Fix for BUG #3626974
                    if(xfaUtil.isWebkit() && !this.options.showCalendarIcon) {
                        this._curInstance.$field.trigger("onoverlap.datetimepicker");
                    }
                }
                styles.top = newTop + "px";
            }
            if(left + this.$dp.outerWidth(true) > windowScrollX + windowInnerWidth ) {
                //align with the right edge
                newLeft = windowScrollX + windowInnerWidth - this.$dp.outerWidth(true) - BUFFER_SPC;
                styles.left = newLeft + "px";
            }
            xfaUtil.$css(this.$dp.get(0), styles);
            return this;
        },

        /*
         * layout the nextView. if nextView is null return
         *
         */
        _layout: function(nextView) {
            if(nextView == null) {
                this._hide();
            } else {
                if(this.view)
                    this['$'+this.view.toLowerCase()].hide();
                this.view = nextView;
                this.$caption.toggleClass("disabled",!viewAction[this.view].caption);
                this['$'+this.view.toLowerCase()].show();
                this["show"+this.view]();
            }
            return this;
        },

        /*
         * show the month view
         */
        showMonth: function() {
            var self = this,
                curDate = new Date(this.currentYear, this.currentMonth),
                maxDay =   this._maxDate(this.currentMonth),
                prevMaxDay = this._maxDate((this.currentMonth + 11)%12),
                day1 = new Date(this.currentYear,this.currentMonth,1).getDay(),
                data,display;

            this.tabulateView(
                {
                    caption: this.options.locale.months[this.currentMonth] + ", "+ this._convertNumberToLocale(this.currentYear),
                    header:this.options.locale.days,
                    numRows:7,
                    numColumns:7,
                    elementAt: function(row,col) {
                        var day = (row-1)*7 + col - day1 + 1;
                        var monthVal = self.currentMonth + 1;
                        display = self._convertNumberToLocale(day);
                        data = day;
                        if(day < 1) {
                            display = self._convertNumberToLocale(prevMaxDay + day);
                            data = -1;
                            monthVal = self.currentMonth;
                        }
                        else if(day > maxDay) {
                            display = self._convertNumberToLocale(day-maxDay);
                            data = -1;
                            monthVal = self.currentMonth + 2;
                        }
                        else {
                            curDate.setDate(day);
                            var compareFn = xfalib.ut.XfaUtil.prototype._compareVal;
                            // check if the currentdate is valid based on max and min valid date
                            if(compareFn(curDate, self.maxValidDate, self.exclMaxDate) || compareFn(self.minValidDate, curDate, self.exclMinDate)) {
                                data = -1;
                            }
                        }
                        return {
                            data : data,
                            display : display,
                            ariaLabel : self.options.editValue(self.currentYear+"-"+self._pad2(monthVal)+"-"+self._pad2(display))
                        };
                    }
                });
        },



        /*
         * show the year view
         */
        showYear: function() {
            var self = this,
                minDate = this.minValidDate ? new Date(this.minValidDate.getFullYear(), this.minValidDate.getMonth()) : null,
                maxDate = this.maxValidDate ? new Date(this.maxValidDate.getFullYear(), this.maxValidDate.getMonth()) : null,
                curDate = new Date(this.currentYear, 0), //can't omit month, if only one param present it is treated as millisecond
                data,
                month;
            this.tabulateView(
                {
                    caption : this._convertNumberToLocale(this.currentYear),
                    numRows : 4,
                    numColumns : 3,
                    elementAt : function(row,col) {
                        data = month =  row*3 + col;
                        curDate.setMonth(month);
                        if ((minDate && curDate < minDate) || (maxDate && curDate > maxDate)) {
                            data = -1;
                        }
                        return {
                            data : data,
                            display : self.options.locale.months[month],
                            ariaLabel : self.options.locale.months[month] + " " +self.currentYear
                        };
                    }
                });
        },

        /*
         * show the year set view
         */
        showYearset: function() {
            var year,
                minDate = this.minValidDate ? new Date(this.minValidDate.getFullYear(), 0) : null ,
                maxDate = this.maxValidDate ? new Date(this.maxValidDate.getFullYear() + 1, 0) : null,
                curDate = new Date(),
                data,
                self = this;
            this.tabulateView(
                {
                    caption: this._convertNumberToLocale(this.currentYear - this.options.yearsPerView/2) +"-"+this._convertNumberToLocale(this.currentYear - this.options.yearsPerView/2 + this.options.yearsPerView - 1),
                    numRows:4,
                    numColumns:4,
                    elementAt: function(row,col) {
                        data = year =  self.currentYear - 8 + (row*4 + col);
                        curDate.setFullYear(year);
                        if ((minDate && curDate < minDate) || (maxDate && curDate > maxDate)) {
                            data = -1;
                        }
                        return {
                            "data" : data,
                            "display" : self._convertNumberToLocale(year),
                            ariaLabel : year
                        };
                    }
                });
        },

        insertRow :  function(rowNum,rowArray,isHeader,height) {
            var $view = this["$"+this.view.toLowerCase()],
                width = (this.actualWidth)/rowArray.length,
                $row = $("ul",$view).eq(rowNum),
                items,$li,element,$tmp,
                self= this;
            if(!$row.length)
                $row = $("<ul></ul>").attr("aria-label", "").attr("role", "row").appendTo($view).toggleClass(headerClass,isHeader);
            $row.height(height);
            items = $("li",$row).length;
            while(items++ < rowArray.length) {
                $tmp = $("<li></li>").attr("role", "cell").appendTo($row);
                if(!isHeader)
                    $tmp.on("click", $.proxy(this._selectDate,this));
            }

            _.each(rowArray, function(el,index) {
                $li = $("li",$row).eq(index);
                if(isHeader)
                    $li.text(rowArray[index]);
                else {
                    element = rowArray[index];
                    xfaUtil.$data($li.get(0), "value", element.data);
                    if(self._checkDateIsFocussed(element.data)) {
                        if(self.$focusedDate) {
                            self.$focusedDate.removeClass("dp-focus");
                            self.$focusedDate.attr("tabindex", "-1");
                        }
                        self.$focusedDate = $li;
                        if(self._keysEnabled)
                            self.$focusedDate.addClass("dp-focus")
                    }
                    $li.toggleClass("dp-selected",self._checkDateIsSelected(element.data))
                        .toggleClass("disabled", element.data == -1).text(element.display)
                        .attr("title", element.ariaLabel)
                        .attr("aria-label", element.ariaLabel)
                        .attr("tabindex", -1);
                }
                $li.css( {"height":height+"px","width":width+"px","line-height":height+"px"});
            });
            return $row;
        },

        /*
         * creates a tabular view based on the options provided. The options that can be passed are
         * numRows: number of rows that needs rendering
         * numCols: number of columns that needs rendering
         * caption: text for the datepickers caption element
         * header: an array of elements that identifies the header row
         * elementAt: a function(row, column) that returns an object (data: <data>, display: <display>) where
         *            <data> is the value to set for that view when the element at (row,column) is clicked and
         *            <display> is the value that will be visible to the user
         */
        tabulateView : function(options) {
            var r = 0,rows = 0,
                row = [],
                ht =  this.options.viewHeight/options.numRows,
                c;
            this.$caption.text(options.caption);
            if(options.header) {
                this.insertRow(r++,options.header,true,ht);
            }
            while(r < options.numRows) {
                c = 0;
                while(c < options.numColumns) {
                    row[c] = options.elementAt(r,c);
                    c++;
                }
                this.insertRow(r++,row,false,ht);
            }
        },

        _activateField : function(evnt) {
            this._curInstance = xfaUtil.$data(evnt.target,"datetimepicker");
            this._curInstance.$field.trigger("onfocus1.datetimepicker").addClass("datePickerTarget");
            // Issue LC-7049:
            // datepickerTarget should be added when activate the field and should be removed
            // after the fields gets deactivated.
            if (this.options.showCalendarIcon) {
                this._curInstance.$field.parent().addClass("datePickerTarget");
            }
            //enable hot keys only for non touch devices
            if(!this.touchSupported && !this._keysEnabled) {
                $(window).on("keydown.datetimepicker", $.proxy(this._hotKeys,this));
                this._keysEnabled = true;
            }
        },

        _deactivateField: function() {
            if(this._curInstance) {
                if(this._keysEnabled) {
                    $(window).off("keydown.datetimepicker")
                    this._keysEnabled = false;
                }
                //Bug#3607499: on deactivate check the value in the input box, if that is
                // different than the selected Date, change the selectedDate
                //if (this._curInstance.selectedDate != this._curInstance.$field.val()) {
                //    this._curInstance.selectedDate = this._curInstance.$field.val();
                //}
                this._curInstance.$field.trigger("onfocusout.datetimepicker").removeClass("datePickerTarget");
                // Issue LC-7049:
                // datepickerTarget should be added when activate the field and should be removed
                // after the fields gets deactivated. Otherwise clicking on any other datefield
                // will not hide the existing datepicker
                if (this.options.showCalendarIcon) {
                    this._curInstance.$field.parent().removeClass("datePickerTarget");
                }
                this._curInstance = null;
            }
        },

        _hide: function() {
            if(this._visible) {
                this.$dp.hide();
                this._curInstance.$field.trigger("onclose.datetimepicker");
                this._visible = false;
                if (this.options.showCalendarIcon) {
                    this._curInstance.$field.attr('readonly', false);    // when the datepicker is deactivated, activate the field
                }
            }
        },

        _adjustDate: function(step, view, focus) {
            var maxDate,prevMaxDate;
            var _focus = focus || false;
            switch(view.toLowerCase()) {
                case "day":
                    this.currentDay += step;
                    maxDate = this._maxDate(this.currentMonth)
                    if(this.currentDay < 1) {
                        prevMaxDate =  this._maxDate((this.currentMonth - 1 + 12)%12);
                        this.currentDay = prevMaxDate + this.currentDay;
                        return this._adjustDate(-1, "month", _focus);
                    }
                    if(this.currentDay > maxDate) {
                        this.currentDay -= maxDate;
                        return this._adjustDate(+1, "month", _focus);
                    }
                    break;
                case "month":
                    this.currentMonth += step;
                    if(this.currentMonth > 11) {
                        this.currentYear++;
                        this.currentMonth = 0;
                    }
                    if(this.currentMonth < 0) {
                        this.currentYear--;
                        this.currentMonth = 11;
                    }
                    break;
                case "year":
                    this.currentYear += step;
                    break;
                case "yearset":
                    this.currentYear += step*this.options.yearsPerView;
                    break;
            }
            this._layout(this.view);
            if (_focus) {
                this.focusedOnDatepickerItem = true;
                this.$focusedDate.attr("tabindex", 0)[0].focus();
            }
        },

        _checkDateIsSelected: function(data) {
            switch(this.view.toLowerCase()) {
                case "month":
                    return this.currentYear == this.selectedYear && this.currentMonth == this.selectedMonth && data == this.selectedDay;
                case "year":
                    return this.currentYear == this.selectedYear && this.selectedMonth == data;
                case "yearset":
                    return this.selectedYear == data;
            }
        },

        _checkDateIsFocussed: function(data) {
            switch(this.view.toLowerCase()) {
                case "month":
                    return data == this.currentDay;
                case "year":
                    return this.currentMonth == data;
                case "yearset":
                    return this.currentYear == data;
            }
        },

        _convertNumberToLocale : function(number) {
            var zeroCode = this.options.locale.zero.charCodeAt(0);
            number += "";
            var newNumber = [];
            for(var i = 0;i < number.length;i++) {
                newNumber.push(String.fromCharCode(zeroCode + parseInt(number.charAt(i))));
            }
            return newNumber.join("");
        },

        _clearDate: function() {
            var isDateEmpty = this._curInstance.$field.val() ? false : true;
            this.selectedYear
                = this.selectedMonth
                = this.selectedYear
                = -1;
            this._curInstance.selectedDate = "";
            this._curInstance.$field.val("");
            if (!isDateEmpty) {
                this._curInstance.$field.trigger("onvaluechange.datetimepicker", [
                    {selectedDate: ""}
                ]);
            }
            $(".dp-selected",this['$'+this.view.toLowerCase()]).removeClass("dp-selected");
        },

        getEvent : function() {
            return "click";//this.touchSupported ? "touchstart" : "click";
        },

        _pad2: function(m) {
            return m = m < 10 ?"0"+m:m;
        },

        toString : function() {
            return this.selectedYear +"-"+this._pad2(this.selectedMonth + 1)+"-"+this._pad2(this.selectedDay);
        },

        _selectDate : function(evnt) {
            var val = xfaUtil.$data(evnt.target, "value"),
                nextView = viewAction[this.view].li,
                editVal;
            //disabled dates have a value of -1. Do nothing in that case
            if(val == -1)
                return;
            switch(this.view.toLowerCase()) {
                case "month":
                    this.selectedMonth = this.currentMonth;
                    this.selectedYear = this.currentYear;
                    this.selectedDay = val;
                    this._curInstance.selectedDate = this.toString();
                    editVal = this._curInstance.editValue(this.toString());
                    this._curInstance.$field.val(editVal).focus();
                    this._curInstance.$field.trigger("onvaluechange.datetimepicker", [
                        {selectedDate: editVal}
                    ]);
                    $(".dp-selected",this['$'+this.view.toLowerCase()]).removeClass("dp-selected");
                    $(evnt.target).addClass("dp-selected");
                    break;
                case "year":
                    this.currentMonth = val;
                    break;
                case "yearset":
                    this.currentYear = val;
                    break;
            }
            this._layout(nextView);
            //manually focus on the field if clicked on the popup buttons for non-touch device
            if(!this.touchSupported) {
                //No need to focus if selection is made by pressing space.
                if(!this.hotKeyPressed) {
                    this.scriptFocus = true;
                    if(nextView == null) {
                        this.focusedOnDatepickerItem = false;
                    }
                }
            } else if(nextView == null){
                //For touch devices, deactivate the field if a selection is made
                this.focusedOnDatepickerItem = false;
                this._deactivateField()
            }
        },

        _leapYear : function() {
            return this.currentYear % 400 == 0 || (this.currentYear % 100 != 0 && this.currentYear % 4 == 0);
        },

        _maxDate : function(m) {
            if(this._leapYear() && m == 1)
                return 29;
            else return dates[m];
        },

        _access: function(val) {
            if(typeof val == "undefined")
                return this.access
            this.access = val;
        },

        _value:function(val) {
            if(typeof val == "undefined")
                return this.$field.val()
            else {
                this.selectedDate = val;
                var editValue = this.editValue(val);
                // update the field val with provided value instead of null
                if (!editValue) {
                    editValue = val;
                }
                this.$field.val(editValue);
            }
        }
    });

    var adobeDateTimePicker = new DateTimePicker();

    $.fn.adobeDateTimePicker = function(options, value) {
        if(!adobeDateTimePicker.initialized) {
            adobeDateTimePicker.create(options);
            adobeDateTimePicker.initialized = true;
        }
        if(typeof options === "object") {
            adobeDateTimePicker._attachField(this, options);
        }
        else if(typeof options === "string") {
            if(arguments.length == 2)
                adobeDateTimePicker["_"+options].apply(xfaUtil.$data(this[0],"datetimepicker"),[value])
            else
                return adobeDateTimePicker["_"+options].apply(xfaUtil.$data(this[0],"datetimepicker"))
        }
        return this;
    }
})(_, $, xfalib);
(function (xfalib) {
    xfalib.ut.TouchUtil = (function () {
        var touchAvailable = !!("ontouchstart" in window || window.DocumentTouch && document instanceof DocumentTouch) ,
            pointerEnabled = !!(window.MSPointerEvent || window.PointerEvent) ,
            POINTER_DOWN_EVENT = "mousedown",
            POINTER_MOVE_EVENT = "mousemove",
            POINTER_UP_EVENT = "mouseup",
            EVENT_TYPE = "MouseEvent";

        if (window.PointerEvent) { //> IE11
            POINTER_DOWN_EVENT = "pointerdown";
            POINTER_MOVE_EVENT = "pointermove";
            POINTER_UP_EVENT = "pointerup";
            EVENT_TYPE = "PointerEvent";

        } else if (window.MSPointerEvent) { // IE10
            POINTER_DOWN_EVENT = "MSPointerDown";
            POINTER_MOVE_EVENT = "MSPointerMove";
            POINTER_UP_EVENT = "MSPointerUp";
            EVENT_TYPE = "MSPointerEvent" ;

        } else if (touchAvailable) {  // other touch devices
            POINTER_DOWN_EVENT = "touchstart";
            POINTER_MOVE_EVENT = "touchmove";
            POINTER_UP_EVENT = "touchend";
            EVENT_TYPE = "TouchEvent";
        }
        return {
            TOUCH_ENABLED: touchAvailable,
            // new MS Pointer Events
            POINTER_EVENT: EVENT_TYPE,
            POINTER_ENABLED: pointerEnabled,
            POINTER_DOWN: POINTER_DOWN_EVENT,
            POINTER_MOVE: POINTER_MOVE_EVENT,
            POINTER_UP: POINTER_UP_EVENT,
            getTouchEvent: function (evt) {
                var target;
                if (pointerEnabled) {
                    target = evt.originalEvent;
                } else if (touchAvailable) {
                    target = evt.originalEvent || evt;
                    target = target.touches[0];
                    //if (evt.originalEvent && evt.originalEvent.changedTouches && evt.originalEvent.changedTouches[0]) {
                    //    te = evt.originalEvent.changedTouches[0];
                    //}
                }

                return target || evt;
            },
            getPointerEvent: function (eventType) {
                var event = null;
                if ((typeof PointerEvent) === "function") {
                    event = new PointerEvent(eventType, {
                        bubbles: true,
                        cancelable: true
                    });
                } else {
                    event = document.createEvent(EVENT_TYPE);
                    event.initEvent(eventType, true, true);
                }
                return event;
            },
            getTouches:function(evt){
                var touches = [];
                if(touchAvailable && evt.originalEvent && evt.originalEvent.touches ){
                    touches = evt.originalEvent.touches;
                }
                return touches;
            }
        };
    })();
})(xfalib);
(function ($, _) {
    $.widget("xfaWidget.abstractWidget", {

        $userControl: null,

        $data: xfalib.ut.XfaUtil.prototype.$data,

        $css: xfalib.ut.XfaUtil.prototype.$css,

        getOrElse: xfalib.ut.Class.prototype.getOrElse,

        dIndexOf: xfalib.ut.XfaUtil.prototype.dIndexOf,

        btwn: xfalib.ut.XfaUtil.prototype.btwn,

        logger: xfalib.ut.XfaUtil.prototype.getLogger,

        localeStrings: xfalib.ut.XfaUtil.prototype.getLocaleStrings,

        logMsgs: xfalib.ut.XfaUtil.prototype.getLogMessages,

        errorManager: xfalib.ut.XfaUtil.prototype.getErrorManager,

        _widgetName: "abstractWidget",

        // if there are any specific black listed attributes, each widget should define their own
        _blackListedAttributes : ["type"],

        options: {
            name: "",
            value: null,
            commitProperty: "value",
            displayValue: null,
            screenReaderText: null,
            tabIndex: 0,
            role: null,
            paraStyles: null,
            dir: null,
            errorMessage: null,
            warningMessage: null,
            hScrollDisabled: false,
            placeholder:"",
            isValid:true,
            mandatory: false
        },

        getOptionsMap: function () {
            return {
                "tabIndex": function (val) {
                    this.$userControl.attr("tabindex", val);
                },
                "role": function (val) {
                    if (val)
                        this.$userControl.attr("role", val);
                },
                "screenReaderText": function (val) {
                    if (val)
                        this.$userControl.attr("aria-label", val)
                },
                "paraStyles": function (val) {
                    if (val)
                        this.$css(this.$userControl.get(0), val);
                },
                "dir": function (val) {
                    if (val)
                        this.$userControl.attr("dir", this.options.dir);
                },
                "height": function (val) {
                    if (val) {
                        this.$css(this.$userControl[0], {"height": val})
                    }
                },
                "width": function (val) {
                    if (val)
                        this.$css(this.$userControl[0], {"width": val})
                },
                "isValid": function (val) {
                    if(val){
                      this.$userControl.removeAttr("aria-invalid");
                    } else {
                      this.$userControl.attr("aria-invalid",true);
                    }
                },
                "color" : function(value) {
                    if(!_.isEmpty(value)) {
                        var color = "rgb(" + value + ")";
                        this.$css(this.$userControl[0], {"color": color});
                    }
                },
                "font-style" : function (value) {
                    if (!_.isEmpty(value)) {
                        this.$css(this.$userControl[0], {"font-style": value});
                    }
                },
                "mandatory" : function (value) {
                    if(value){
                        this.$userControl.attr("aria-required", true);
                    } else {
                        this.$userControl.removeAttr("aria-required");
                    }
                }
            };
        },

        getEventMap: function () {
            return {
                "focus": xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
                "blur": xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                "click": xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT
            };
        },

        /**
         * Copies all the attributes from source jquery object to destination jquery object
         * @param $src      source jquery object
         * @param $dest     destination jquery object
         */
        copyAttributesFromSrcToDest : function($src, $dest){
            var that = this;
            // let's get all the attribute from the src element and copy it to dest jquery object
            if($src != null && $src[0] && $src[0].attributes && $dest != null){
                $.each($src[0].attributes, function() {
                    // we don't add the black listed set of attributes
                    if(this.specified && this.value != null && _.isString(this.value) && this.value.length > 0 && that._blackListedAttributes.indexOf(this.name) === -1) {
                        $dest.attr(this.name, this.value);
                    }
                });
            }
        },

        _create: function () {
            this.widgetEventPrefix = "";
            this.element.addClass(this._widgetName);
            this.$userControl = this.render();
            this.optionsHandler = this.getOptionsMap();
            this.eventMap = this.getEventMap();
            this._initializeOptions();
            this._initializeEventHandlers();
            this.errObj = this.errorManager();
            //call it only after render
            // Dirty hack to prevent this being called in Guide
            if (typeof guidelib === "undefined") {
                this.$css(this.$userControl.get(0), {
                    "box-sizing": "border-box",
                    "position": "absolute"
                });
            }
        },

        _initializeEventHandlers: function () {
            xfalib.ut.XfaUtil.prototype.getLogger().debug("xfa", "initialize event handlers for " + this._widgetName);
            _.each(this.eventMap, function (xfaevent, htmlevent) {
                var self = this;
                if (xfaevent) {
                    if (!(xfaevent instanceof  Array)) {
                        xfaevent = [xfaevent];
                    }
                    for (var i = 0; i < xfaevent.length; i++) {
                        xfalib.ut.XfaUtil.prototype.getLogger().debug("xfa", "binding " + htmlevent + " with " + xfaevent[i]);
                        this.$userControl.on(htmlevent,
                            (function (xfevnt) {
                                return function (evnt) {
                                    xfalib.ut.XfaUtil.prototype.getLogger().debug("xfa", "trigger " + evnt.type +
                                    " xfa-event " + xfevnt);
                                    self._preProcessEvent.apply(self, [xfevnt, evnt]);
                                    //since the fix https://github.com/jquery/jquery/pull/972, Fix for keeping namespace when triggering an event using an Event #972
                                    //we need to clear the namespace and its regular expression of triggering event, as the listeners are registered on un-namespaced events
                                    evnt.namespace = "";
                                    evnt.namespace_re = "";
                                    self._trigger(xfevnt, evnt);
                                    self._postProcessEvent.apply(self, [xfevnt, evnt]);
                                }
                            })(xfaevent[i])
                        )

                    }
                }
            }, this)
        },

        _preProcessEvent: function (xfaevent, htmlevent) {
            if (xfaevent == this.options.commitEvent) {
                this.preProcessCommit(htmlevent);
            }
            switch (xfaevent) {
                case xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT:
                    this.preProcessEnter(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT:
                    this.preProcessExit(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT:
                    this.preProcessChange(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT:
                    this.preProcessClick(htmlevent);
                    break;
            }

        },

        _postProcessEvent: function (xfaevent, htmlevent) {
            if (xfaevent == this.options.commitEvent) {
                this.postProcessCommit(htmlevent);
            }
            switch (xfaevent) {
                case xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT:
                    this.postProcessEnter(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT:
                    this.postProcessExit(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT:
                    this.postProcessChange(htmlevent);
                    break;
                case xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT:
                    this.postProcessClick(htmlevent);
                    break;
            }
        },

        _initializeOptions: function () {
            _.each(this.optionsHandler, function (value, key) {
                if (typeof value === "function")
                    value.apply(this, [this.options[key]]); // TODO: check whether it is needed for initialization or not
            }, this)
        },

        _setOption: function (key, value) {
            if (this.options[key] != value) {
                this.options[ key ] = value;
                if (typeof this.optionsHandler[key] === "function") {
                    this.optionsHandler[key].apply(this, [this.options[key]])
                }
            }
        },

        /**
         * @override
         */
        option: function (key, value) {
            if (arguments.length === 1 &&
                typeof key === "string" &&
                this.options.hasOwnProperty(key) &&
                this.options[key] === undefined) {
                return undefined;
            }
            return $.Widget.prototype.option.apply(this, arguments)
        },

        destroy: function () {
            this.$userControl.removeClass(this._widgetName);
        },


        render: function () {
            var control;
            if (this.element.children().length > 0) {
                control = $(this.element.children().get(0));
            }
            else
                control = this.element;
            control.attr("name", this.options.name)
            return control;
        },


        preProcessCommit: function (evnt) {
            this.options.value = this.getCommitValue();
            xfalib.ut.XfaUtil.prototype.getLogger().debug("xfa", "passing commit value " + this.options.value +
            "to model ");
        },

        getCommitValue: function () {

        },

        preProcessExit: function (evnt) {

        },

        preProcessEnter: function (evnt) {
            //Only focus the enabled widgets
            if (this.options.access === "open") {
                this._showError();
                this.showValue();
            }
        },

        preProcessChange: function (evnt) {

        },

        preProcessClick: function (evnt) {

        },

        postProcessCommit: function (evnt) {
            this.showDisplayValue();
        },

        postProcessExit: function (evnt) {
            //Only for the enabled widgets
            if (this.options.access === "open") {
                this.showDisplayValue();
                this._hideError();
            }
        },

        postProcessEnter: function (evnt) {
        },

        postProcessChange: function (evnt) {

        },

        postProcessClick: function (evnt) {

        },

        showDisplayValue: function () {
            this.$userControl.val(this.options.displayValue)
        },

        /**
         * Checks if the edit value is same as value present in the user control(html form element)
         * @returns {boolean}
         */
        _isValueSame : function(){
            return (((this.options.value === null) && (this.$userControl.val() === "")) || (this.options.value === this.$userControl.val()));
        },

        showValue: function () {
            // May be $userControl doesn't have val(), using it as of now
            // If the value of the field is not same as edit value, only then set the value, this also solves IE bug of cursor
            // moving to the end of field on click
            if(!this._isValueSame()) {
                this.$userControl.val(this.options.value)
            }
        },

        focus: function () {
            var that = this;
            // setTimeout added to fix CQ-51141
            // While using setFocus API in adaptive form, the focus was not being set in TextBox on chrome
            // and also on click of caption of RadioButton/Checkbox, due to fast event execution, hence adding delay during focus.
            setTimeout(function(){
                that.$userControl[0].focus();
            }, 1);
        },

        click: function () {
            this.focus();
            this.$userControl.triggerHandler("click"); // we do not want the exact click as might bubble up to the field.
        },

        /* widget specific code */

        _showError: function () {
            if(this.errObj && _.isFunction(this.errObj.onFieldEnter)) {
                this.errObj.onFieldEnter(this);
            }
        },

        _calculatePaddingForVAlign:function(diff){
           var flagForMoz = $.browser.mozilla && !xfalib.ut.Utilities.isIE11() &&
                              this.options.multiLine,
               vAlignBottomOrTop = this.options.paraStyles &&
                                   (this.options.paraStyles["vertical-align"] == "bottom" ||
                                    this.options.paraStyles["vertical-align"] == "top");

           if(flagForMoz && vAlignBottomOrTop || $.browser.msie && this.options.multiLine) {
              return;
           }
           // to handle the edge cases, if the diff is like -0.01 the whole operation is getting aborted
           // this diff comes mainly due to scroll height getting rounded off when widgetHeight is like x.999999
           diff = (diff > -0.01) ? Math.abs(diff) : diff;
           if (this.options.paraStyles && diff > 0) {
                var vAlign = this.options.paraStyles["vertical-align"];
                if (vAlign == "bottom") {
                    diff = diff - this.options.paraStyles["padding-bottom"];
                    this.$userControl.css("padding-top", diff);
                    this.padding = this.$userControl.css("padding-top");
                }
                else if (vAlign == "top" || (vAlign != "middle" && vAlign == undefined)) {
                    if (this.options.paraStyles["padding-top"])
                        diff = diff - this.options.paraStyles["padding-top"];
                    this.$userControl.css("padding-bottom", diff);
                    this.padding = this.$userControl.css("padding-bottom");
                }
                else if (this.options.multiLine && vAlign == "middle") {
                    var newDiff = diff / 2;
                    newDiff = newDiff - this.options.paraStyles["padding-bottom"];
                    if (this.options.paraStyles["padding-top"])
                        newDiff = newDiff + this.options.paraStyles["padding-top"];
                    this.$userControl.css("padding-top", newDiff);
                }
            }
        },

        _handleVAlignOnExit: function (evnt) {

            if (!this.options.paraStyles) {
                //vAlign has to be handled only if there is paraStyles
                return;
            }
            var value = this.options.displayValue,
                lineHeight = xfalib.view.util.TextMetrics.measureExtent(value, {refEl: this.$userControl.get(0), maxHeight: -1}).height,
                widgetHeight = this.options.height,
                diff = widgetHeight - lineHeight;
            this._calculatePaddingForVAlign(diff);

        },

        _handleVAlignOnEnter: function (evnt) {
            //Only align the enabled widgets
            var flagForIE = $.browser.msie && this.options.multiLine;
            if (this.options.paraStyles && !flagForIE) {
                 var vAlign = this.options.paraStyles["vertical-align"];
                 if (vAlign == "bottom" && this.padding)
                     this.$userControl.css("padding-top", this.padding);
                 else if (vAlign == "top" && this.padding)
                     this.$userControl.css("padding-bottom", this.padding);
            }
        },

        _hideError: function () {
            if(this.errObj && _.isFunction(this.errObj.onFieldExit)) {
                this.errObj.onFieldExit(this);
            }
        },

        markError: function (msg, type) {
            if(this.errObj && _.isFunction(this.errObj.markError)) {
                this.errObj.markError(this, msg, type);
            }
        },

        clearError: function () {
            if(this.errObj && _.isFunction(this.errObj.clearError)) {
                this.errObj.clearError(this);
            }
        },

        getEditValue: function(value) {
            if(this.options.editPattern == null) {
                return value;
            }
            try {
                return xfalib.ut.PictureFmt.format(value, this.options.editPattern);
            } catch(e) {
                return null;
            }
        },

        parseEditValue: function(value) {
            if(this.options.editPattern == null) {
                return value;
            }
            try {
                return xfalib.ut.PictureFmt.parse(value, this.options.editPattern);
            } catch(e) {
                return value;
            }
        }
    });
})($, window._);
(function($) {
    $.widget( "xfaWidget.defaultWidget", $.xfaWidget.abstractWidget, {

        _widgetName: "defaultWidget",

        getOptionsMap: function() {
            var parentOptionsMap = $.xfaWidget.abstractWidget.prototype.getOptionsMap.apply(this,arguments);
            return $.extend({},parentOptionsMap,{
                "access": function(val) {
                    switch(val) {
                        case "open" :
                            this.$userControl.removeAttr("readOnly");
                            this.$userControl.removeAttr("aria-readonly");
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                        case "nonInteractive" :
                        case "protected" :
                            this.$userControl.attr("disabled", "disabled");
                            this.$userControl.attr("aria-disabled", "true");
                            break;
                        case "readOnly" :
                            this.$userControl.attr("readOnly", "readOnly");
                            this.$userControl.attr("aria-readonly", "true");
                            break;
                        default  :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                    }
                },

                "displayValue": function(val) {
                    if(this.options.commitProperty) {
                        if($.browser.mozilla && this.options.commitProperty == "value") {
                            // on submitting form firefox does not remember autocomplete values, if updated through attr()
                            this.$userControl.val(this._displayEmptyStringForIE(this.options.displayValue));
                        } else {
                            this.$userControl.prop(this.options.commitProperty, this._displayEmptyStringForIE(this.options.displayValue));
                            this.$userControl.attr(this.options.commitProperty, this._displayEmptyStringForIE(this.options.displayValue));
                        }
                    } else {
                        this.logger().debug("xfaView", "[DefaultWidget._update], User Control or Commit Property is null");
                    }
                },

                "placeholder": function(value){
                    this.$userControl.attr("placeholder", value);
                }
            });
        },

        _displayEmptyStringForIE: function(value){
            /*CQ-69417: By default "null" is displayed in the comments text box
              "null" values shown in IE */
            // CQ-69107 included check for edge as well
            return (value == null && xfalib.ut.XfaUtil.prototype.detectIE()) ? '' : value;
        },

        render : function() {
            var control = $.xfaWidget.abstractWidget.prototype.render.apply(this,arguments)
            this._attachEventHandlers(control)
            return control
        },

        getCommitValue: function() {
            var value = this.$userControl.val();
            if(this.options.hScrollDisabled && !this.options.multiLine)
                var value = xfalib.ut.XfaUtil.prototype.splitStringByWidth(this.$userControl.val(),this.$userControl.width(),this.$userControl.get(0)) ;
            return value;
        },

        _attachEventHandlers: function($control) {
            $control.keydown($.proxy(this._handleKeyDown,this));
            $control.keypress($.proxy(this._handleKeyPress,this));
            $control.on('paste',$.proxy(this._handlePaste,this));
            $control.on('cut',$.proxy(this._handleCut,this));
        },

        _compositionUpdateCallback : function (event) {
            return false;
        },

        _attachCompositionEventHandlers : function($control) {
            var isComposing = false; // IME Composing going on
            var hasCompositionJustEnded = false; // Used to swallow keyup event related to compositionend
            // IME specific handling, to handle japanese languages max limit
            // since enter can also be invoked during composing, a special handling is done here
            var that = this,
                changeCaratPosition = function() {
                    // change the carat selection position to further limit input of characters
                    var range = window.getSelection();
                    range.selectAllChildren(that.$userControl[0]);
                    range.collapseToEnd();
                };
            $control.keyup(function(event) {
                if (/*isComposing || */hasCompositionJustEnded) {
                    if (that._compositionUpdateCallback(event)) {
                        changeCaratPosition();
                    }
                    // IME composing fires keydown/keyup events
                    hasCompositionJustEnded = false;
                }
            });
            $control.on("compositionstart",
                function(event) {
                    isComposing = true;
                })
                .on("compositionupdate",
                    function(event) {
                        // event.originalEvent.data refers to the actual content
                        if (that._compositionUpdateCallback(event)) {
                            changeCaratPosition();
                        }
                    })
                .on("compositionend",
                    function(event) {
                        isComposing = false;
                        // some browsers (IE, Firefox, Safari) send a keyup event after
                        //  compositionend, some (Chrome, Edge) don't. This is to swallow
                        // the next keyup event, unless a keydown event happens first
                        hasCompositionJustEnded = true;
                    })
                .on("keydown",
                    function(event) {
                        // Safari on OS X may send a keydown of 229 after compositionend
                        if (event.which !== 229) {
                            hasCompositionJustEnded = false;
                        }
                    });
        },

        _handleKeyDown : function(event){
            if(event.keyCode == 13 || event.charCode == 13 || event.which == 13) // touch devices may return charCode
                event.preventDefault();
        },

        _handleKeyPress : function(event){
            if(event.keyCode == 13 || event.charCode == 13 || event.which == 13) // touch devices may return charCode
                event.preventDefault();
        }
    });
})($);
(function($, _) {
    var xfaUtil = xfalib.ut.XfaUtil.prototype;
    $.widget( "xfaWidget.dateTimeEdit", $.xfaWidget.defaultWidget, {

        _widgetName : "dateTimeEdit",

        getEventMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
            if(this._nativeWidget === false) {
                return $.extend({}, parentOptionsMap, {
                    "onfocus1.datetimepicker": xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
                    "onvaluechange.datetimepicker": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    "onfocusout.datetimepicker": xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    "onoverlap.datetimepicker": xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT, // Custom Event to fix BUG #3626974
                    "input": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT, // TODO : add handler for xfa.event.change
                    "focus": null,
                    "blur": null
                })
            } else {
                return $.extend({}, parentOptionsMap, {
                    "change": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
                })
            }
        },

        _getAdobeDatePickerOptionsMap : function(parentOptionsMap) {
            return {
                "access" : function (val) {
                    switch (val) {
                        case "open" :
                            this.$userControl.adobeDateTimePicker("access", true);
                            break;
                        case "nonInteractive" :
                        case "protected" :
                        case "readOnly" :
                            this.$userControl.adobeDateTimePicker("access", false);
                            break;
                    }
                    parentOptionsMap.access.apply(this, arguments);
                },
                "displayValue" : function (val) {
                    // set the value in the datepicker plugin
                    this.$userControl.adobeDateTimePicker("value", this.options.value);
                    // show the display value
                    this.showDisplayValue();
                }
            }
        },

        _getNativeDatePickerOptionsMap: function (parentOptionsMap) {
            return {
                "displayValue": function (val) {
                    this.showDisplayValue();
                }
            }
        },


        getOptionsMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments),
                datePickerOptions = this._nativeWidget === false ? this._getAdobeDatePickerOptionsMap(parentOptionsMap)
                    : this._getNativeDatePickerOptionsMap(parentOptionsMap),
                commonOptions = {
                    "paraStyles": function (paraStyles) {
                        parentOptionsMap.paraStyles.apply(this, arguments);
                        this._handleVAlignOnExit();
                    },

                     "access": function(val) {
                        // update width on change of access (as width of widget is dependent on access)
                        // The calender icon should be hidden, and widget should take full space when readOnly
                        parentOptionsMap.access.apply(this, arguments);
                        this.getOptionsMap().width.apply(this,[this.options.width]);
                      },
                     "width": function (val) {
                        parentOptionsMap.width.apply(this, arguments);
                        if (this.options.showCalendarIcon && val && this.options.access == "open") {
                            var effectiveWidth = val > this.options.calendarIconWidth ? val - this.options.calendarIconWidth : val;
                            this.$userControl.width(effectiveWidth);  // leave space for the cal icon
                        }
                    },

                    "height": function(val) {
                        parentOptionsMap.height.apply(this, arguments);
                        this._handleVAlignOnExit();
                    },
                    "screenReaderText": function (val) {
                        var editPattern = this.options.editPattern;
                        var defaultEditPattern = this._nativeWidget ? "mm/dd/yyyy" : "YYYY-MM-DD";
                        var regex = /(?:date){0,1}{(.*)}/; // date{<pattern>} or {<pattern>} both are valid as per xfa spec
                        editPattern = typeof editPattern === "string" ? editPattern.match(regex)[1] : defaultEditPattern;
                        var defaultLabel = "Please Enter date in {0} format only";
                        if (editPattern) {
                            var ariaLabel = xfalib.ut.LocalizationUtil.prototype.getLocalizedMessage("",
                                xfalib.locale.Strings.datePickerAriaLabel || defaultLabel, [editPattern])
                        }
                        var finalVal = val !== undefined ? val + " " + ariaLabel : val;
                        this.$userControl.attr("aria-label", finalVal);
                    }
                };
            return $.extend({},parentOptionsMap,datePickerOptions, commonOptions);
        },

        postProcessExit: function(evnt) {
            $.xfaWidget.defaultWidget.prototype.postProcessExit.apply(this,arguments);
            this._handleVAlignOnExit ();
        },

        preProcessEnter: function(evnt) {
            $.xfaWidget.defaultWidget.prototype.preProcessEnter.apply(this,arguments);
            this._handleVAlignOnEnter();
        },

        preProcessChange: function(evnt) {
           //CQ-46332:loss of date value in date-picker , setting the value here or else
           //it gets lost during focus
           if(this._nativeWidget === true){
            this.options.value = this.$userControl.val();
           }
        },

        showDisplayValue: function() {
            if(this._nativeWidget === false) {
                $.xfaWidget.defaultWidget.prototype.showDisplayValue.apply(this, arguments);
            } else {
                this.showValue();
            }
        },


        showValue: function () {
            if (this._nativeWidget == false) {
                this.$userControl.adobeDateTimePicker("value", this.options.value);
            } else {
                $.xfaWidget.defaultWidget.prototype.showValue.apply(this, arguments);
            }
            $.xfaWidget.textField.prototype._selectOnFocusInIE.apply(this, arguments);
        },

        getCommitValue: function() {
            if (this._nativeWidget === false) {
                var value = this.$userControl.adobeDateTimePicker("value"),
                    parsedValue = this.parseEditValue(value);
                return parsedValue;
            }
            return $.xfaWidget.defaultWidget.prototype.getCommitValue.apply(this, arguments);
        },

        render: function() {
            var self = this,
                textStyle = this.getOrElse(this.$data(this.element.get(0), "xfamodel"), "textstyle", ""),
                $control = $.xfaWidget.abstractWidget.prototype.render.apply(this, arguments),
                $source = $control,
                id,
                existingInlineStyleAttributeValues,
                newInlineStyleAttributeValues,
                combinedInlineStyleAttributeValues;
            existingInlineStyleAttributeValues = this.element.find("input").attr("style") || '';
            this._nativeWidget = true;
            if(this.options.useNativeWidget === false || $control[0].type !== "date") {
                this._nativeWidget = false;
                id = this.element.find("input")[0].id;
                this.element.children().remove();
                $("<div></div>").css({position: "relative", width: "100%", height: "100%"}) // want to fill entire width of containing table cell
                    .append($("<input type='text'/>"))
                    .appendTo(this.element);
                $control = $("input", this.element).
                    attr("style", textStyle).
                    attr("name", this.options.name).
                    attr("id", id).
                    adobeDateTimePicker({
                        positioning: this.element,
                        locale: {
                            months: this.options.months,
                            days: this.options.days,
                            zero: this.options.zero,
                            clearText: this.options.clearText
                        },
                        access: this.options.access,
                        value: this.options.value,
                        showCalendarIcon: this.options.showCalendarIcon,
                        iconWidth: this.options.calendarIconWidth,
                        minValidDate : this.options.minValidDate,
                        maxValidDate : this.options.maxValidDate,
                        exclMinDate :  this.options.exclMinDate,
                        exclMaxDate : this.options.exclMaxDate,
                        editValue: function (value) {
                            return self.getEditValue(value);
                        }
                    });
            }
            this._attachEventHandlers($control);
            newInlineStyleAttributeValues = this.element.find("input").attr("style") || '';
            //append the previous inlineStyleAttributeValues to newInlineStyleAttributeValues so that the inline styles
            //added from the dialog are applied.
            combinedInlineStyleAttributeValues = newInlineStyleAttributeValues + existingInlineStyleAttributeValues;
            this.element.find("input").attr("style", combinedInlineStyleAttributeValues);
            // only in case of adaptive form, we would copy the attributes back
            if(window.guideBridge) {
                // restore the original attribute back to destination object
                this.copyAttributesFromSrcToDest($source, this.element.find("input"));
            }
            return $control;
        }
    }) ;

})($, _);
(function($, _) {
$.widget("xfaWidget.numericInput", $.xfaWidget.defaultWidget, {

    _widgetName: "numericInput",

	options : {
		value : null,
		curValue: null,
        pos: 0,
        lengthLimitVisible: true,
        zero:"0",
        decimal:".",
        minus:"-"
	},

    //TODO: to support writing in different locales \d should be replaced by [0-9] for different locales
    _matchArray : {
                    "integer":"^[+-]?{digits}*$",
                    "decimal":"^[+-]?{digits}{leading}({decimal}{digits}{fraction})?$",
                    "float":"^[+-]?{digits}*({decimal}{digits}*)?$"
                  },

    _regex : null,

    _engRegex : null,

    _writtenInLocale : false,

    _previousCompositionVal : "",


    _toLatinForm : function (halfOrFullWidthStr) {
        // refer http://www.fileformat.info/info/unicode/block/halfwidth_and_fullwidth_forms/utf8test.htm
        return halfOrFullWidthStr.replace(
            /[\uff00-\uffef]/g,
            function(ch) { return String.fromCharCode(ch.charCodeAt(0) - 0xfee0); }
        );
    },

    getOptionsMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "paraStyles": function(paraStyles){
                parentOptionsMap.paraStyles.apply(this,arguments);
                this._handleVAlignOnExit ();
            } ,

            "height": function(val) {
                if(val)   {
                    this.$css(this.$userControl[0],{"height" :val});
                    this._handleVAlignOnExit();    // To Handle the case of expandable Fields
                }
            }

        })
    },

    getEventMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "onKeyInput.numericInput" : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
        })
    },

    _getDigits: function() {
        var zeroCode = this.options.zero.charCodeAt(0),
            digits = "";
        for(var i = 0;i < 10;i++) {
            digits += String.fromCharCode(zeroCode + i);
        }
        return "["+digits+"]"
    },

    _escape: function(str) {
      return str.replace(".","\\.")
    },

    postProcessExit: function(evnt) {
        $.xfaWidget.defaultWidget.prototype.postProcessExit.apply(this,arguments);
        this._handleVAlignOnExit ();
    },

    preProcessEnter: function(evnt) {
        $.xfaWidget.defaultWidget.prototype.preProcessEnter.apply(this,arguments);
        this._handleVAlignOnEnter();
    },

	render : function() {
        var matchStr =  this._matchArray[this.options.dataType];
        if(matchStr) {
            var ld = this.options.leadDigits,
                fd = this.options.fracDigits,
                ldstr = ld && ld != -1 ? "{0,"+ld+"}"
                    : "*",
                fdstr = fd && fd != -1 ? "{0,"+fd+"}"
                    : "*",
                matchStr =  matchStr.replace("{leading}",ldstr)
                                    .replace("{fraction}",fdstr),
                localeStr = matchStr.replace(/{digits}/g,this._getDigits())
                                    .replace("{decimal}",this._escape(this.options.decimal)),
                engStr = matchStr.replace(/{digits}/g,"[0-9]")
                                .replace("{decimal}","\\.")
            this._processValue = !(this._getDigits() == "[0123456789]" && this.options.decimal == ".")
            this._regex = new RegExp(localeStr, "g");
            this._engRegex = new RegExp(engStr, "g");
        }
        return $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
    },

    getCommitValue: function() {
        var value = $.xfaWidget.defaultWidget.prototype.getCommitValue.apply(this, arguments);
        // we support full width, half width and locale specific numbers
        value = this._toLatinForm(value);
        if(value.length > 0 && this._processValue && !value.match(this._engRegex)) {
            this._writtenInLocale = true;
            value = this._convertValueFromLocale(value);
        } else {
            this._writtenInLocale = false
        }
        if(value && value.length >= this.options.combCells )
            value = value.slice(0,this.options.combCells);
        this._previousCompositionVal = value;
        return value;
    },

    _compositionUpdateCallback : function (event) {
        var that = this;
        var flag = false;
        var leadDigits = that.options.leadDigits;
        var fracDigits = that.options.fracDigits;
        // we don't check use-case where just fracDigits is set since in case of composition update, the value to update is not known
        if (leadDigits !== -1) {
            var val = that.$userControl.val();
            if (event.type === "compositionupdate" && event.originalEvent.data) {
                val = val + event.originalEvent.data.substr(event.originalEvent.data.length - 1);
            }
            // can't use the existing regex (since current regex checks for english digits), rather doing leadDigit compare
            var totalLength = leadDigits + (fracDigits !== -1 ? (fracDigits + that.options.decimal.length) : 0);
            if (val.indexOf(that.options.decimal) === -1) {
                totalLength = leadDigits;
            }
            var latinVal = this._toLatinForm(val);
            // match both since we support full width, half width and locale specific input
            var match = latinVal.match(that._regex)|| latinVal.match(this._engRegex);
            flag  = !match;
            if (match === null) {
                // entered invalid character, revert to previous value
                that.$userControl.val(that._previousCompositionVal);
                flag = true;
            } else if (flag) {
                // if max reached
                var newVal = val.substr(0, totalLength);
                that.$userControl.val(newVal);
                that._previousCompositionVal = newVal;
                flag = true;
            } else {
                that._previousCompositionVal = val;
            }
        }
        return flag;
    },

    _attachEventHandlers : function($control) {
        $.xfaWidget.defaultWidget.prototype._attachEventHandlers.apply(this, arguments);
        // IME specific handling, to handle japanese languages max limit
        $.xfaWidget.defaultWidget.prototype._attachCompositionEventHandlers.apply(this, arguments);
	},

    _handleKeyInput : function(event, character, code){
        if(event.ctrlKey && !_.contains(['paste', 'cut'], event.type)) {
            return true;
        }

        $.xfaWidget.defaultWidget.prototype._handleKeyDown.apply(this,arguments);
        this.options.lengthLimitVisible = true;

        var val = this.$userControl.prop(this.options.commitProperty) || '',
            // if selectionStart attribute isn't supported then its value will be undefined
            selectionStart = xfalib.view.util.HtmlUtil.getHTMLSupportedAttr(this.$userControl[0], "selectionStart"),
            isSelectionAttrSupported = !(selectionStart === undefined || selectionStart === null),
            selectionStart = selectionStart || 0,
            selectionEnd = xfalib.view.util.HtmlUtil.getHTMLSupportedAttr(this.$userControl[0], "selectionEnd") || 0,
            combCells = parseInt(this.options.combCells) || 0,
            current,
            change = character;

        if (combCells > 0 ) {
            change = character.substr(0, combCells - val.length + selectionEnd - selectionStart);
        }

        current = val.substr(0, selectionStart) + change + val.substr(selectionEnd);
        // done to handle support for both full width, half width or mixed input in number field
        var latinCurrentValue = this._toLatinForm(current);

	// we want to check regex first and then see whether it was numeric or not.
        if (!(this._regex == null || latinCurrentValue.match(this._regex) || latinCurrentValue.match(this._engRegex))) {
            event.preventDefault();
            return false;
        }

	// CQ-4245407 : selectionStart and selectionEnd attributes aren't supported in case of input type = number
        // it is used for providing native HTML5 implementation for numeric field, so no further processing is required
        // As it is specific to AF and AF doesn't support change event on each keypress, so this change should be fine
        if (!isSelectionAttrSupported) {
            return true;
        }

        if (!_.contains(['keydown', 'cut'], event.type) && combCells && (val.length >= combCells || current.length > combCells) && selectionStart === selectionEnd) {
            event.preventDefault();
            return false;
        }

        this.options.curValue = val;
        this._previousCompositionVal = val;
        this.options.pos = selectionStart;

        if(this.options.hScrollDisabled && !_.contains(['keydown', 'cut'], event.type)) {
            var expectedWidth = xfalib.view.util.TextMetrics.measureExtent(current, {refEl: this.$userControl[0], maxWidth:-1}).width;
            if(!event.ctrlKey && expectedWidth > this.$userControl.width() - 5){
                event.preventDefault();
                this.options.lengthLimitVisible = false;
            }
        }

        this.$userControl.trigger({
            type : "onKeyInput.numericInput",
            originalType : event.type,
            character : character,  // contains the pasted string or pressed key
            keyCode : event.keyCode || 0,
            charCode : event.charCode || 0,
            which : event.which || 0,
            ctrlKey : event.ctrlKey || event.metaKey || false,
            shiftKey : event.shiftKey || false,
            keyDown : false, // This property is available only for list boxes and drop-down lists
            selectionStart: selectionStart,
            selectionEnd: selectionEnd
        });
    },

    _handleKeyDown : function(event){
        if (event) {
            var code = event.charCode || event.which || event.keyCode || 0;
            if(code == 8 || code == 46) // backspace and del
               this._handleKeyInput(event, "", code);
            else if(code == 32) { // suppress space
                event.preventDefault();
                return false;
            }
        }
    },

    _isValidChar: function (character) {
        character = this._toLatinForm(character);
        var lastSingleDigitChar = String.fromCharCode(this.options.zero.charCodeAt(0) + 9);
        // we only full width, half width and also locale specific if customer has overlayed the i18n file
        return (character >= "0" && character <= "9") || (character>=this.options.zero && character<=lastSingleDigitChar) || character===this.options.decimal || character===this.options.minus;
    },

    _handleKeyPress : function(event){
        if (event) {
            var code = event.charCode || event.which || event.keyCode || 0,
                character = String.fromCharCode(code);

            if(xfalib.ut.XfaUtil.prototype.isNonPrintableKey(event.key)) { // mozilla also generates a keypress, along with keydown
                return true;                                               // for all keys, so only handling printable keys in keypress
            }

            if (this._isValidChar(character))
                this._handleKeyInput(event, character, code);
            else if (!event.ctrlKey){
                event.preventDefault();
                return false;
            }
        }
    },

    _handlePaste : function(event){
        if (event) {
            var pastedChar = undefined;
            if (window.clipboardData && window.clipboardData.getData) { // IE
                pastedChar = window.clipboardData.getData('Text');
            } else if (event.originalEvent.clipboardData && event.originalEvent.clipboardData.getData) {
                pastedChar = event.originalEvent.clipboardData.getData('text/plain');
            }

            if(pastedChar) {
                var allPastedCharsValid = _.every(pastedChar.split(''), function (character) {
                    return this._isValidChar(character);
                }, this);
                if (allPastedCharsValid) {
                    // during paste we support both half width, full width and locale specific numbers
                    pastedChar = this._toLatinForm(pastedChar);
                    this._handleKeyInput(event, pastedChar, 0);
                }
                else if (!event.ctrlKey) {
                    event.preventDefault();
                    return false;
                }
            }
        }
    },

    _handleCut : function(event) {
        if (event) {
            this._handleKeyInput(event, "", 0);
        }
    },
    // CQ-107886 : added handling for negative values, as for '-', '-3' was getting returned
    _convertValueToLocale: function(val) {
        var zeroCode = this.options.zero.charCodeAt(0);
        return  _.map(val,function(c) {
            if(c == ".") {
                return this.options.decimal;
            } else if(c == "-") {
                return this.options.minus;
            } else {
                return String.fromCharCode(parseInt(c) + zeroCode);
            }
        },this).join("");
    },

    _convertValueFromLocale: function(val) {
        val = this._toLatinForm(val);
        var zeroCode = this.options.zero.charCodeAt(0);
        return  _.map(val,function(c) {
            if(c == this.options.decimal) {
                return ".";
            } else if(c == this.options.minus) {
                return "-";
            } else {
                return (c.charCodeAt(0) - zeroCode).toString();
            }
        },this).join("");
    },

    showValue : function() {
       // if the value is same, don't do anything
       if(!this._isValueSame()){
           if(this.options.value && this._writtenInLocale) {
               this.$userControl.val(this._convertValueToLocale(this.options.value))
           } else {
               this.$userControl.val(this.options.value)
           }
       }
       //IE doesn't show selected text if we focus and set its value all the time so force selection
       $.xfaWidget.textField.prototype._selectOnFocusInIE.apply(this, arguments);
    }
});
})($, window._);(function ($, _) {
    $.widget("xfaWidget.dropDownList", $.xfaWidget.defaultWidget, {            //commitEvent: change; commitProperty: value<Array>

        _widgetName: "dropDownList",

        options: {
            value: [],
            items: [],
            editable: false,
            placeholder: "",
            displayValue: []
        },

        widgetSkeleton: '<select name="" style="" size = "1"></select>',
        optionSkeleton: '<option data-user-option></option>',
        optGroupSkeleton: '<optgroup label=""></optgroup>',
        AF_OPTGROUP_NAME: "afOptGroupName",
        PLACE_HOLDER_STYLE_CLASS : "placeHolder",

        getOptionsMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "value": function (val) {
                    if (!_.isArray(val)) {
                        val = [val];
                    }
                    var selectedOptionFound = false,
                        that = this;
                    //sync option selection as per new values
                    $("option", this.$userControl).each(function (index) {
                        var selectValue = $(this).val();
                        //Check if this value is present in options value array
                        if (_.contains(val, selectValue)) {
                            $(this).prop("selected", true);
                            selectedOptionFound = true;
                        } else {
                            $(this).prop("selected", false);
                            if (this.id === "emptyValue") {
                                $(this).val("").html(that.options.placeholder);
                                //Hiding emptyValue with no placeholder text configured.
                                if(that.options.placeholder.length == 0) {
                                    $(this).hide();
                                }
                            }
                        }
                    });

                    /* Add default option if :
                    / 1. If placeholder add an extra option
                    / 2. If the value is set anything other than the options (and null/"") create a new option
                     */
                    if ((!selectedOptionFound && val.length != 0 && val[0] != null) || that.options.placeholder.length != 0) {
                        if (this.$userControl.children('[data-empty-option]').length == 0) {
                            var extraOption = document.createElement("option");
                            extraOption.setAttribute("data-empty-option", "");
                            extraOption.setAttribute("role", "none");
                            extraOption.setAttribute("value", "")
                            this.$userControl[0].insertBefore(extraOption, this.$userControl[0].firstChild);
                        }
                        // If placeholder is present the set value of empty option to placeholder
                        if (that.options.placeholder.length != 0) {
                            this.$userControl.children('[data-empty-option]').text(that.options.placeholder);
                        }
                        // If placeholder is present and value is not present then select placeholder
                        if (val.length == 0 || val[0] == null) {
                            this.$userControl.children('[data-empty-option]').prop("selected", true);
                        } // If value is set anything other than option then set empty option to value
                        else if (!selectedOptionFound && val.length != 0 && val[0] != null) {
                            this.$userControl.children('[data-empty-option]').text(val[0]).
                            prop("selected", true).
                            val(_.escape(val[0])).
                            show();
                        }

                    }
                    else if (that.options.placeholder.length == 0) {
                        // Delete default option if value is found in options while adding options
                        if (selectedOptionFound && this.$userControl.children('[data-empty-option]').val() != that.options.displayValue) {
                            if (this.$userControl.children('[data-empty-option]').length > 0) {
                                this.$userControl[0].removeChild(this.$userControl.children('[data-empty-option]')[0]);
                            }
                        }
                        // Reset the value of dropdown based on rule
                        else if (!selectedOptionFound && (val.length == 0 || val == null || val[0] == null)) {
                            this.$userControl[0].value = "";
                        }
                    }
                    this.$userControl.toggleClass(this.PLACE_HOLDER_STYLE_CLASS, val.length == 0 || val == null);
                },

                "items": function (val) {
                    if (!_.isArray(val)) {
                        val = [val];
                    }

                    var AF_OPTGROUP_NAME = "afOptGroupName";
                    var i, j, optgroupOptions = [], element, $viewOptgroup, $preOptgroup;
                    var viewOptgroups = $("optgroup", this.$userControl);
                    // Removes all options which earlier didn't belong to any optgroup.
                    if (viewOptgroups.length == 0) {
                        // save selected value because when value is set before items in setWidgetOptions
                        // the selected value would get lost in html
                        var selectedOption = this.$userControl.find('[selected]');
                        this.$userControl.children("option[data-user-option]").remove();
                    }
                    for (i = 0, j = 0; j < val.length; j++) {
                        element = val[j];
                        if (element.save != AF_OPTGROUP_NAME) {
                            // Add options to String[] which will be later synced to the optgroup.
                            optgroupOptions.push(element);
                        } else {
                            $viewOptgroup = viewOptgroups[i++];
                            // When optgroup is less than the required optgroups.
                            if (i > viewOptgroups.length) {
                                $viewOptgroup = this.addGroup(element.display);
                            }
                            // Undefined as it may not occur even once when list is purely of options.
                            if (!_.isUndefined($viewOptgroup) && $viewOptgroup.label != element.display) {
                                $viewOptgroup.label = element.display || '';
                            }
                            // Check to skip the first optgroup.
                            if (j != 0) {
                                // Syncs options to the prev optgroup.
                                // Prev optgroup because current optgroup marks the end of options of prev.
                                this.handleOptions($preOptgroup, optgroupOptions);
                                // Clear options of the optgroup for next optgroup.
                                optgroupOptions = [];
                            }
                            $preOptgroup = $viewOptgroup;
                        }
                    }
                    // Removes all extra optgroups.
                    while (i < viewOptgroups.length) {
                        $viewOptgroup = viewOptgroups[i++];
                        this.deleteGroup($viewOptgroup.label);
                    }
                    //Add remaining options to respective optgroup.
                    if (optgroupOptions.length != 0) {
                        this.handleOptions($preOptgroup, optgroupOptions, selectedOption);
                    }

                    //Intentionally left the selection check -> I am relying on the fact that "value" sync event is called after "items" sync.
                },

                "displayValue": function () {
                },
                "placeholder": function(value){
                    // overriding the default handling of place holder options setter
                },
                "access": function (val) {
                    switch (val) {
                        case "open" :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            this.$userControl.removeAttr("aria-readonly");
                            var options = this.$userControl[0];
                            if(options && options.length > 0) {
                                _.each(this.$userControl[0], function (element) {
                                    element.removeAttribute("disabled");
                                });
                            }
                            break;
                        case "nonInteractive" :
                        case "protected" :
                            // In case of nonInteractive and protected, field should be disabled and cannot be tabbed.
                            this.$userControl.attr("disabled", "disabled");
                        case "readOnly" :
                            this.$userControl.attr("aria-disabled", "true");
                            this.$userControl.attr("aria-readonly", "true");
                            var options = this.$userControl[0];
                            if(options && options.length > 0) {
                                _.each(this.$userControl[0], function (element) {
                                    element.disabled = true;
                                });
                            }
                            break;
                        default  :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            this.$userControl.removeAttr("aria-readonly");
                            break;
                    }
                }
            })
        },

        getEventMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "focus": [xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT, xfalib.ut.XfaUtil.prototype.XFA_PREOPEN_EVENT],
                "change": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
            })
        },

        render: function () {
            var existingInlineStyleAttributeValues = this.element.find("select").attr("style"),
                newInlineStyleAttributeValues,
                combinedInlineStyleAttributeValues,
                size = 1;

            this.element.addClass(this._widgetName);
            this.element.children().remove();

            var inputName = _.uniqueId("select"),  //Unique Id
                textStyle = this.getOrElse(this.$data(this.element.get(0), "xfamodel"), "textstyle", ""),
                $widgetSkeleton = $(this.widgetSkeleton)
                                    .attr('style', textStyle)
                                    .attr('name', inputName);
            if(this.options.editable) {
                $widgetSkeleton.addClass('combobox');
            }

            if(this.options.items && this.options.items.length>0){
                size = this.options.items.length
            }
            if(this.options.multiSelect) {
                $widgetSkeleton.addClass('multiDropdown');
                $widgetSkeleton.attr('multiple','multiple');
                $widgetSkeleton.attr('size',size);
                $widgetSkeleton.attr('data-multiple-selection',"true");
            }

            var $parEl = $widgetSkeleton;
            _.each(this.options.items, function(item){
                var saveItem = _.isString(item.save) ? item.save.replace(/\"/g, "&quot;") : "";
                if (saveItem === this.AF_OPTGROUP_NAME){ // assuming optgroups appear before options
                    $parEl = $(this.optGroupSkeleton).attr('label', item.display).appendTo($widgetSkeleton);
                } else {
                    $(this.optionSkeleton).val(saveItem).text(item.display).appendTo($parEl);
                }
            },this);

            this.element.append($widgetSkeleton);

            var control = this.element.children().eq(0).attr("name", this.options.name);
            this._attachEventHandlers(control);
            newInlineStyleAttributeValues = this.element.find("select").attr("style");
            //append the previous inlineStyleAttributeValues to newInlineStyleAttributeValues so that the inline styles
            //added from the dialog are applied.
            combinedInlineStyleAttributeValues = newInlineStyleAttributeValues + existingInlineStyleAttributeValues;
            this.element.find("select").attr("style", combinedInlineStyleAttributeValues);
            return control;
        },

        //syncs the options to the optgroup dynamically.
        handleOptions : function ($viewOptgroup, val, selectedOption) {
            //When the list so far consists purely of options.
            if (_.isUndefined($viewOptgroup)) {
                $viewOptgroup = this.$userControl[0];
            }
            var viewOptions = $("option[data-user-option]", $viewOptgroup);
            //Syncs the value of options.
            for (var i = 0, j = 0; i < viewOptions.length && j < val.length; i++, j++) {
                var $viewOption = viewOptions[i];
                var element = val[j];
                if ($viewOption.text != element.display) {
                    $viewOption.text = element.display || '';
                }
                if ($viewOption.value != element.save) {
                    $viewOption.value = element.save || '';
                }
            }
            //Deletes options if count is more than required.
            while (i < viewOptions.length) {
                this.deleteOption(viewOptions[i++])
            }
            //Add options if count is less than required.
            while (j < val.length) {
                this.addOption($viewOptgroup, val[j++], selectedOption);
            }
            // Set empty value to dropdown if placeholder and default value is not present
            if (this.options.placeholder.length == 0) {
            	if (this.checkForEmptyValue(this.options.value)) {
            		this.$userControl[0].value = "";
            	}
            }
            // since options are removed and added again during items we need to set the access again options.
            this.optionsHandler["access"].apply(this, [this.options["access"]]);
        },

        addOption : function ($viewOptgroup, element, selectedOption) {
            var $newOption = $(this.optionSkeleton).val(element.save).text(element.display);
            $newOption.appendTo($viewOptgroup);
            if(selectedOption) {
                if(element.save === selectedOption.val() && element.display === selectedOption.text()) {
                    $newOption.prop("selected", true);
                }
            }
            // Since the displayValue is a '\n' separated string of selected values in case of multiSelect,
            // we convert it to an array and check whether that array contains the save value of the element
            var values;
            if (this.options.value && _.isString(this.options.value)) {
                values = this.options.value.split('\n');
            } else if (_.isArray(this.options.value)) {
                // In the case of AF we have value/displayValue as an array
                values = this.options.value
            }
            if (values && values.indexOf(element.save) >= 0) {
                //Delete emptyValue with no placeholder text configured and value is found in options
                if (this.options.placeholder.length == 0 && this.$userControl.children('[data-empty-option]').length > 0) {
                    this.$userControl[0].removeChild(this.$userControl.children('[data-empty-option]')[0]);
                }
                this.$userControl.children().filter(function() {
                    return this.value == element.save;
                }).prop("selected", true);
            }
        },

        deleteOption: function ($viewOption) {
            this.$userControl.find('option[value='+$viewOption.value+']').remove();
        },

        checkForEmptyValue: function(value) {
            if ((value && _.isArray(value) && value[0] == null) || (this.options.value == null))
                return true;
            else
                return false;
        },

        addGroup: function(label) {
            //Creates a optgroup Node.
            var optionGroup = document.createElement("OPTGROUP");
            optionGroup.label = label;
            this.$userControl[0].appendChild(optionGroup);
            return optionGroup;
        },

        deleteGroup: function(label) {
            this.$userControl.children().remove('optgroup[label='+label+']');
        },

        addItem: function(itemValues) {
            var newOption = new Option(itemValues.sDisplayVal || '', itemValues.sSaveVal || ''),
                val = this.options.value;
            this.$userControl[0].add(newOption, null);
            // if item has same value as present in options then mark it as selected
            if (_.contains(val, itemValues.sSaveVal)) {
                this.$userControl.find("option[value=" + itemValues.sSaveVal + "]").prop("selected", true);
                var emptyValue = this.$userControl.children('[data-empty-option]');
                if (emptyValue.length > 0 && emptyValue.val() === itemValues.sSaveVal) {
                    this.$userControl[0].removeChild(emptyValue[0]);
                }
            } else if ((val == null || val.length == 0 || val[0] == null) && this.options.placeholder.length == 0) {
                // Value should remain empty if option is not already selected & placeholder is empty
                this.$userControl[0].value = "";
            }
        },

        clearItems: function () {
            //Deleting all the options including optGroup except the empty value.
            this.$userControl.children().not('[data-empty-option]').remove();
        },

        deleteItem: function (nIndex) {
            //check for emptyValue instead of blindly doing + 1
            if (this.$userControl[0].item(0) && this.$userControl[0].item(0).id == "emptyValue")
                nIndex = nIndex + 1;
            //if there is emptyValue element then just delete one index higher
            //this check is must instead of blindly increasing the index by 1 because NWKListBox extends this class and that doesn't maintain emptyValue
            this.$userControl[0].remove(nIndex);
        },

        getCommitValue: function (event) {
            var value = $("option:selected", this.$userControl).map(function () {
                return $(this).val();
            }).get();
            return value;
        },

        showDisplayValue: function () {
        },

        destroy: function () {
            this.element.
                removeClass(this._widgetName).
                children().remove().
                text("");

            // call the base destroy function
            $.xfaWidget.defaultWidget.prototype.destroy.apply(this, arguments);
        },

        _handleKeyDown: function (event) {

            if (event.keyCode == 13) {
                //do nothing
                //just override the return key behaviour and over to defaultWidget for rest of the stuff.
                //return key is intercepted to avoid submission of form which is default behavior of html form element
                //but as a side effect it also stops the closing of drop down only in IE -> probably I should use IE condition but
                // this code works fine in          chrome as well so keeping it that way.
                //watson bug#3675141
            }
            else
                $.xfaWidget.defaultWidget.prototype._handleKeyDown.apply(this, arguments);
        },

        // CQ-51462 : focus and commit event (change) happen together hence first selection was modifying the value
        // we do not want focus to modify the value that is about to be committed
        showValue : function() {

        }
    });
})($, _);
(function($, _){
	$.widget( "xfaWidget.listBox", $.xfaWidget.defaultWidget, {

    _widgetName: "listBoxWidget",

    options : {
        value : [],
        items : [],
        multiSelect : false
    },

    getOptionsMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "width" : function(val) {
                //Bug#3597771. setting the height more than 0.95 brings scrollbar
                this.options.width = val*0.95
                parentOptionsMap.width.apply(this,[this.options.width])
            },
            "access" : function() {},
            "value": function(val) {
                var newValues = this.options.value,
                    self = this,
                    tabSet = false;
                if(!_.isArray(newValues))
                    newValues = [newValues];
                var tabSet
                this.$userControl.children().each(function(){
                    var saveVal = $(this).attr("data-save");

                    // Check if this value is present in options value array
                    if(newValues && _.contains(newValues, saveVal)){
                        self._selectListItem($(this));
                        tabSet = true;

                        // Set the selected data attribute to true.
                        if (!$.data(this, "_xfaInitialized")) {
                            //Initialized data- attributes parse for once using this call.
                            // Next onward don't use this. Instead use $.data which is cheap/
                            $(this).data();
                            $.data(this, "_xfaInitialized", true); //Mark the element to say that data has been initialized.
                        }
                        $.data(this, "selected", true);

                    }
                    else{
                        $(this).removeClass("item-selected");
                        $(this).addClass("item-selectable");
                        $(this).attr("tabIndex", "-1");
                    }
                });
                if(!tabSet) {
                    $(this.$userControl.children().get(0)).attr("tabIndex", this.options.tabIndex);
                }
            },

            "items" : function(val) {
                if(!_.isArray(val))
                    val = [val];
                var viewItems = this.$userControl.children();

                //if number of items are not same in model and view then balance it
                if((viewItems.length) > val.length){
                    for(var i=viewItems.length; i >  val.length; i--){
                        this.deleteItem(i-1);
                    }
                }
                else if((viewItems.length) < val.length){
                    for(var i=viewItems.length; i < (val.length); i++){
                        this.addItem({sDisplayVal: val[i].display, sSaveVal: val[i].save});
                    }
                }

                _.each(val, function(element, index){
                    var $viewItem = $(viewItems[index]);
                    if( $viewItem.text() != element.display){
                        $viewItem.text(element.display || '');
                    }

                    if( $viewItem.attr("data-save") != element.save){
                        $viewItem.attr("data-save", element.save || '');
                    }
                });

                //Intentionally left the selection check -> I am relying on the fact that "value" sync event is called after "items" sync.
            },

            "displayValue" : function(){;},

            "tabIndex": function() {
                var selectedItem = this.$userControl.children(".item-selected"),
                    children =this.$userControl.children()
                if(selectedItem.length) {
                    selectedItem.eq(0).attr("tabIndex", this.options.tabIndex);
                }
                else if(children.length > 0) {
                    children.eq(0).attr("tabIndex", this.options.tabIndex);
                }
            }
        })
    },

    getEventMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "listboxenter":xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
            "listboxexit":xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
            "listboxchange":xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
            "focus":null,
            "blur":null
        })
    },

    showDisplayValue : function() {
        },

    render : function() {
        this.element.addClass( this._widgetName);
        this.element.children().remove();

        //TODO: add a function for geting textStyle
        var textStyle = this.getOrElse(this.$data(this.element.get(0), "xfamodel"), "textstyle", ""),
            that = this,
            //Bug#3597771 width and height are provided by the view itself.
            listElTemplate =
            '<ol style="position:absolute;<%=textStyle%>" role="listbox">' +
                '<% _.each(items, function(item){ %>' +
                '<% var saveItem = item.save ? item.save.replace(/\"/g,"&quot;"):null %>'+
                    '<li role="option" data-save="<% print(saveItem) %>" data-selected="false"><% print(item.display) %></li>'+
                '<%})%>'+
            '</ol>',
            compiledListElTemplate = _.template(listElTemplate),
            templateOptions = _.extend({
                "textStyle" : textStyle
                }, this.options),
            resolvedListEl = compiledListElTemplate(templateOptions);
        that.element.html(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(resolvedListEl));
        var control = $(that.element.children().get(0)).attr("name",this.options.name);
        this._attachEventHandlers(control);
        return control
    },

    focus: function() {
        if(this.$userControl.children(".item-selected").length > 0) {
            this.$userControl.children(".item-selected")[0].focus();
        }
        else if(this.$userControl.children().length > 0) {
            this.$userControl.children()[0].focus();
        }
    },

    addItem : function(itemValues){
        $("<li></li>")
            .attr("data-save", itemValues.sSaveVal || '')
            .text(itemValues.sDisplayVal || '')
            .appendTo(this.$userControl)
            .click($.proxy(this._handleItemClick, this))
            .focus($.proxy(this._handleItemFocus, this));

        // add new item as selected if the value is already present in options
        if (_.contains(this.options.value, itemValues.sSaveVal)) {
            this._selectListItem(this.$userControl.find("[data-save=" + itemValues.sSaveVal+ "]"));
        }
    },

    clearItems : function(){
        $(this.$userControl).empty();
    },

    deleteItem : function(nIndex){
        $(this.$userControl).children('li').each(function(index,element){
            if(index==nIndex){
                $(element).off("click").off("focus").remove();
            }
        })
    },


    _attachEventHandlers : function($control){
        var self = this;
        $control.keydown($.proxy(this._hotKeys,this))
            .children().on("mousedown",function() {
                    if(self.inFocus == true) {
                        self.mouseDown = true;
                    }
                })
            .click($.proxy(this._handleItemClick, this))
            .focus($.proxy(this._handleItemFocus, this))
            .blur($.proxy(this._handleFocusOut,this))

    },

     _hotKeys : function(event){
         if(this.options.access != "open")
             return;
         if(this.itemInFocus){
             switch(event.which) {
                 case 38: //arrow up
                     var prevSibling = $(this.itemInFocus).prev();
                     if(prevSibling){
                         this.keyDown = true;
                         prevSibling.focus();
                         this.keyDown = false;
                     }
                     event.preventDefault();
                     break;
                 case 40: //arrow down
                     var nextSibling = $(this.itemInFocus).next();
                     if(nextSibling){
                         this.keyDown = true;
                         nextSibling.focus();
                         this.keyDown = false;
                     }
                     event.preventDefault();
                     break;
                 case 91: //left arrow
                 case 92: //right arrow
                     event.preventDefault();
                     break;
                 case 32:
                     this._toggleItem(this.itemInFocus);
                     event.preventDefault();
                     break;
                 default:
             }
         }
     },

     _toggleItem: function(item) {
         var $item = $(item),
             multiMode = this.options.multiSelect, // && event.ctrlKey ;
             that = this;
             //toggle selected state of this item
             this.$data(item, "selected", !this.$data(item, "selected"));
         var state = this.$data(item, "selected")

         if(!multiMode) {
             var $selectedItem = this.$userControl.children(".item-selected")
             if($selectedItem.length) {
                 this.$data($selectedItem[0],"selected",false)
                 $selectedItem.removeClass("item-selected").addClass("item-selectable")
             }
         }
         $item.toggleClass("item-selectable",!state).
               toggleClass("item-selected",state)

         this.$userControl.trigger("listboxchange");
     },

     getCommitValue: function() {
         var that = this,
             multiMode = this.options.multiSelect;


         return this.$userControl.children().map(function(){
             // intentionally using $this.attr("data-save") instead of $this.data("data")
             return that.$data(this, "selected") ? $(this).attr("data-save") : null;
         }).get();
     },

      _handleItemFocus : function(event){
          if(this.options.access != "open")
              return;
          var item = event.target;
          this.itemInFocus = item;

          // overriding default widgets handleFocus
          if(!(this.keyDown || this.mouseDown)) {        //we do not need to fire focus event if
              this.$userControl.trigger("listboxenter")  // clicked on another li element or pressed a key to move the selectio
          }
          this.mouseDown = false;
          this.inFocus = true;
      },

     _handleItemClick : function(event){
        // Bug#3501811 If clicked onlistbox entry more than once, exit event is not fired
        // Clicking on the same entry does not call focus and hence we were not resetting the state. Doing it in onClick
        if(this.mouseDown == true)
            this.mouseDown = false;
        if(this.options.access != "open")
             return;
        this._toggleItem(event.target)
    },

    _handleFocusOut: function(){
        if(!(this.keyDown || this.mouseDown)) {
            this.$userControl.trigger("listboxexit");
            this.inFocus = false
        }
    },

    _selectListItem : function ($elem) {
        if ($elem && $elem.length) {
            $elem.removeClass("item-selectable")
                .addClass("item-selected")
                .attr("tabIndex", this.options.tabIndex);
        }
    },

    destroy: function() {
        this.element.
            removeClass(this._widgetName).
            children().remove().
            text("");

        $.xfaWidget.defaultWidget.prototype.destroy.apply(this, arguments);
    }
});
})($, window._);
(function($) {
    $.widget( "xfaWidget.nwkListBox",  $.xfaWidget.dropDownList, {            //non-webkit listbox

        _widgetName : "nwkListBox",

        options : {
            value : [],
            multiSelect : false
        },

        render : function() {
            var $control = $.xfaWidget.dropDownList.prototype.render.apply(this, arguments);
            if($control){
                $control.children("#emptyValue").remove();
                if(this.options.multiSelect)
                    $control.attr("multiple", "multiple");
            }
            this._updateSelectSize($control);
            return $control;
        },

        addItem : function(itemValues){
            $.xfaWidget.dropDownList.prototype.addItem.apply(this, arguments);
            this._updateSelectSize();
        },

        clearItems : function(){
            $.xfaWidget.dropDownList.prototype.clearItems.apply(this, arguments);
            this._updateSelectSize();
        },

        deleteItem : function(nIndex){
            $.xfaWidget.dropDownList.prototype.deleteItem.apply(this, arguments);
            this._updateSelectSize();
        },

        _updateSelectSize : function($control){
            $control = $control || this.$userControl;
            $control.attr("size", (this.options.items || []).length);
        },

        // Bug#3597771
        // focus and commit event happen together hence first selection was modifying the value
        // we do not want focus to modify the value that is about to be committed
        showValue : function() {

        }

  });
})($);
(function ($) {
    $.widget("xfaWidget.xfaButton", $.xfaWidget.defaultWidget, {            //commitEvent: change; commitProperty: value<Array>

        _widgetName: "xfaButton",

        options: {
            value: null,
            svgCaption: false //option to indicate if button already has an SVG caption
        },

        getOptionsMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "access": function (val) {
                    switch (val) {
                        case "open" :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                        case "nonInteractive" :
                        case "protected" :
                        case "readOnly" :
                            this.$userControl.attr("disabled", "disabled");
                            this.$userControl.attr("aria-disabled", "true");
                            break;
                        default  :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                    }
                },
                "value": function () {
                },
                "displayValue": function () {
                },
                "svgCaption": function (val) {
                    if (val) {
                        this.$userControl.removeAttr("value");
                    }
                }
            })
        },

        _attachEventHandlers: function ($control) {
            $control.click(function () {
                this.focus()
            });
        },

        getCommitValue: function () {
            return this.options.value;
        },

        showValue: function () {
        },

        showDisplayValue: function () {
        }
    });
})($);(function ($) {
    $.widget("xfaWidget.XfaCheckBox", $.xfaWidget.defaultWidget, {            //commitEvent: change; commitProperty: value<Array>

        _widgetName: "XfaCheckBox",

        options: {
            value: null,
            state: -1,
            states: 2,
            values: [],
            mandatory: false
        },

        checkedState: false,
        clickPending: false,

        getOptionsMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "access": function (val) {
                    switch (val) {
                        case "open" :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                        case "nonInteractive" :
                        case "protected" :
                        case "readOnly" :
                            this.$userControl.attr("disabled", "disabled");
                            this.$userControl.attr("aria-disabled", "true");
                            break;
                        default  :
                            this.$userControl.removeAttr("disabled");
                            this.$userControl.removeAttr("aria-disabled");
                            break;
                    }
                },

                "displayValue": function (val) {
                    this.$userControl.attr(this.options.commitProperty, this.options.value);
                    this._state(this.dIndexOf(this.options.values, this.options.value));
                    this.$userControl.attr("checked", this.checkedState ? "checked" : null);
                    this.$userControl.prop("checked", this.checkedState ? "checked" : null);
                    //for accessibility
                    this.$userControl.attr("aria-checked", this.checkedState);
                    if (this.options.state == 2)
                        this.$userControl.addClass("neutral");
                    else if (this.options.states == 3)
                        this.$userControl.removeClass("neutral");   // since current state != neutral
                },

                "allowNeutral": function (val) {
                    var intVal = parseInt(val);
                    if (intVal == 0 || intVal == 1) {
                        this.options.states = 2 + intVal;
                    }
                },

                "paraStyles": function (paraStyles) {
                    parentOptionsMap.paraStyles.apply(this, arguments);
                    this._handleVAlignOnExit();
                }
            })
        },

        getEventMap: function () {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                 "xfacheckboxchange" :  xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                 "xfacheckboxclick" :   xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT,
                 "change": null,
                 "click" : null
               })
        },

        _attachEventHandlers: function ($control) {
            var that = this;
            var focusFunc = function (evnt) {
                if (!that.inFocus) {
                    that.focus();
                    that.inFocus = true;
                }
            }
            var focusOutFunc = function (evnt) {
                that.inFocus = false;
            }
            $control.click(focusFunc).change(focusFunc).blur(focusOutFunc);
            $control.change($.proxy(this._handleChange,this)).click($.proxy(this._handleClick,this));   //LC-5106
        },

        getCommitValue: function () {
            this._state((this.options.state + 1) % this.options.states);
            this.$userControl.attr("checked", this.checkedState ? "checked" : null);
            //for accessibility
            this.$userControl.attr("aria-checked", this.checkedState)
            if (this.options.state == 2) {
                this.$userControl.addClass("neutral");
            }
            else if (this.options.states == 3)
                this.$userControl.removeClass("neutral"); // since current state != neutral

            return this.options.values[this.options.state];
        },

        _handleVAlignOnExit: function (evnt) {
            //--this is being kept empty as no other browser (i.e Mozilla and Chrome) take the padding-bottom or padding-top into account.
            // the only browser to take it into consideration is IE. And moreover the alignment and padding considerations have already been taken into account in
            // calculations in CheckButtonFieldView.js. And on removing the entire function it takes up the _handleVAlignOnExit() of AbstractWidget.

        },

        _handleChange: function (evnt) {
            this.$userControl.trigger("xfacheckboxchange"); //change is always fired
            if(this.clickPending === true) {
              this.clickPending = false;
              this.$userControl.trigger("xfacheckboxclick");
            } else {
                // handling of this.clickPending is added to handle the case when clicked on checkbox/radiobutton label/caption
                this.clickPending = true;
            }
        },

        _handleClick: function (evnt) {
             var isChrome = xfalib.ut.XfaUtil.prototype.detectChrome(),
                 isIE = xfalib.ut.XfaUtil.prototype.detectIE(),
                 isSafari = xfalib.ut.XfaUtil.prototype.isSafari(),
                 userControlType = this.$userControl.attr("type");
             // click will not be fired if the previous state of the radiobutton is 'on'.
             // NPR-35652 : Checkbox movement - Click event works fine on chrome but not in iOS safari for collapsible fields
             // CQ-103023 : Click Event on Radio Button not working correctly in Chrome 53
             // CQ-103715 : CQ-103715 : Click Event on Check Box not working correctly in Chrome and Firefox, added handling for checkbox also
             // handling of this.clickPending is added to handle the case when clicked on checkbox/radiobutton label/caption
             if(($.browser.mozilla || isChrome || isSafari) && !isIE && this.clickPending === false && ((userControlType === "radio" && this.checkedState === false) || (userControlType === "checkbox"))) {
               this.clickPending = true;
             }
             else {
                this.$userControl.trigger("xfacheckboxclick");
                this.clickPending = false;
             }
        },

        _state: function (newState) {
            if (newState == undefined)
                return this.options.state;
            else
                this.options.state = newState;
            this.checkedState = (newState == 0 || newState == 2);
        },

        click: function () {
            // trigger change for check box and for radio only if it is not selected
            // otherwise radio button will go in deselected state
            if (this.$userControl.attr("type") !== "radio" || this.options.state !== 0) {
                this.$userControl.trigger("change");
            }
            //we should call only the handler since calling click will trigger change.
            this.$userControl.triggerHandler("click");
        }
    });
})($);
(function($, _){
    $.widget( "xfaWidget.textField", $.xfaWidget.defaultWidget, {

        _widgetName: "textField",

        options: {
            curValue : null ,
            pos:0,
            lengthLimitVisible: true,
            maxChars:0 ,
            flag:"",
            // by default html5Type is set to true
            // we leverage pattern, maxLength support from HTML5 browser for mobile forms
            html5Type : "text",
            length : null,
            minLength : 0,
            totalLengthMessage : "",
            minimumLengthMessage : "",
        },

        getOptionsMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
            return $.extend({},parentOptionsMap,{
                "maxChars": function(maxchars) {
                    if(this._maxCharsReached(this.options.value)) {
                        var value = this.options.value.slice(0,maxchars)
                        this._setOption("value", value);
                        this._setOption("displayValue", value);
                    }

                },

                "multiLine ": function(val) {
                    if(this.options.multiLine)
                        this.$userControl.attr("aria-multiline", "true");
                    else
                        this.$userControl.removeAttr("aria-multiline", "false");
                },

                "height": function(val) {
                    if(val)   {
                        this.$css(this.$userControl[0],{"height" :val})
                        this._handleVAlignOnExit();    // To Handle the case of expandable Fields
                    }
                },
                "width": function(val){
                    parentOptionsMap.width.apply(this,arguments);
                    // handle valign on width change as well
                    // as content height(scrollHeight) varies according to width
                    this._handleVAlignOnExit();
                },
                "paraStyles": function(paraStyles){
                    parentOptionsMap.paraStyles.apply(this,arguments);
                    this._handleVAlignOnExit();
                }

            })
        },

        render : function() {
            var control = $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
            // use the control to set HTML5 attributes
            if (control && control.length > 0 && this.options.html5Type) {
                var minLength = this.options.minLength,
                    maxLength = this.options.maxChars,
                    length = this.options.length;
                    isMinLengthSet = minLength != null && minLength > 0,
                    isMaxLengthSet = maxLength != null && maxLength > 0,
                    isLengthSet = length != null && length > 0,
                    isMultiline = this.options.multiLine,
                    minLengthMsg = this.options.minimumLengthMessage,
                    totLengthMsg = this.options.totalLengthMessage,
                    pattern = ""; // html5 pattern is not supported for textarea

                // order of execution matters for the below code snippet
                if (isMinLengthSet) {
                    // add minLength though it is not fully supported in all browsers
                    // hence also adding pattern attribute
                    control.attr("minlength", parseInt(minLength));
                    if(minLengthMsg && minLengthMsg.length > 0) {
                        control.attr("title", this.options.minimumLengthMessage); // html5 supported message on pattern validation failure
                    }
                }

                if (isMaxLengthSet) {
                    control.attr("maxlength", parseInt(maxLength));
                }

                // if both min and max length is set
                if(isMinLengthSet && isMaxLengthSet){
                    pattern += ".{" + minLength + "," + maxLength + "}";
                } else if(isMinLengthSet) {
                    // if only min length set
                    pattern += ".{" + minLength + ",}";
                }

                // if length is set then set min and max length in pattern equal to length
                if (isLengthSet) {
                    if(isMultiline){ // set both min and maxlength as pattern is not supported
                        control.attr("minlength", parseInt(length));
                        control.attr("maxlength", parseInt(length));
                    }
                    if(totLengthMsg && totLengthMsg.length > 0) {
                        control.attr("title", this.options.totalLengthMessage);
                    }
                    // reset the pattern string
                    pattern = ".{" + length + "," + length + "}";
                }
                // if required is set, set the required attribute, it is necessary else an empty value will be excluded from constraint validation
                if (this.options.required) {
                    control.attr("required", true);
                }
                // set the pattern if not empty and check if this is not multiline, since pattern is not supported for textarea
                if (pattern && pattern.length > 0 && !isMultiline) {
                    control.attr("pattern", pattern);
                }
            }
            return control;
        },

        /*  This function aligns vAlign when:
         1. parastyles is present and the widget contains a value.
         2. During initial rendering if no content present fallback to the previous logic.
         3. Presence of content in widget.
        */
        _handleVAlignOnExit: function(){
             var value = this.options.displayValue,
                 noContentPresent = _.isEmpty(this.$userControl.val() || this.options.displayValue),
                 contentHeight,widgetHeight,diff,tempCSS;

             //the widget doesn't have value as yet but content exists [ Rendering of widget]
             if (!this.options.paraStyles || noContentPresent) {
                //vAlign has to be handled only if there is paraStyles and widget has content
                return;
             }

             // mozilla results in vAlign regression hence made this change only for textarea
             if($(this.element[0]).find("textarea").length >0 && !noContentPresent)  {
               /* measureExtent not returning correct height of content in textarea even with all
                 css values */
               tempCSS={'height':this.$userControl.css('height'),'padding':this.$userControl.css('padding')};
               this.$css(this.$userControl[0],{'height':'1px','padding':'0px'});

               contentHeight = this._getContentHeight();
               this.$css(this.$userControl[0],tempCSS);
               widgetHeight = this.options.height;
               diff = widgetHeight - contentHeight;
               this._calculatePaddingForVAlign(diff);
             } else {
                // widget has no initial content or is a textfield.Proceed as before.
                $.xfaWidget.defaultWidget.prototype._handleVAlignOnExit.apply(this,arguments);
             }
        },

        getEventMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
            return $.extend({},parentOptionsMap,{
                "onKeyInput.textField" : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
            })
        },

        _maxCharsReached: function(val) {
            var isMaxLengthSupported = false,
                elementName = this.options.multiLine ? "textarea" : "input";
            // in browsers, where max length is supported, we don't custom javascript checks, we let HTML do the validation of max length
            if(this.options.html5Type && xfalib.view.util.HtmlUtil.elementSupportsAttribute(elementName, "maxLength")){
                isMaxLengthSupported = true;
            }
            return !isMaxLengthSupported && this.options.maxChars
                   && this.options.maxChars!=="0"
                   && val
                   &&  val.length >= this.options.maxChars
        },

        _handleKeyInput : function(event, character, code) {
            if(event.ctrlKey && !_.contains(['paste', 'cut'], event.type)) {
                return true;
            }

            if(!this.options.multiLine) {
                $.xfaWidget.defaultWidget.prototype._handleKeyDown.apply(this, arguments);
                character = (code == 13) ? '' : character ;
            }

            var val =  this.$userControl.val(),
                selectionStart = xfalib.view.util.HtmlUtil.getHTMLSupportedAttr(this.$userControl[0], "selectionStart") || 0,
                selectionEnd = xfalib.view.util.HtmlUtil.getHTMLSupportedAttr(this.$userControl[0], "selectionEnd") || 0,
                pos = selectionStart,
                // CQ-4260239 : "&nbsp" taking space of 5 chars for restricting the length to visible area
                newVal = (val.substr(0, selectionStart) + character + val.substr(selectionEnd));
            this.options.curValue = val;
            if(!this.options.multiLine) { //TODO:looks like a bug
                this.options.lengthLimitVisible = true;
                this.options.pos = pos;
                if(this.options.hScrollDisabled && !_.contains(['keydown', 'cut'], event.type)) {
                    var expectedWidth = xfalib.view.util.TextMetrics.measureExtent(newVal, {refEl: this.$userControl[0], maxWidth:-1}).width;
                    if(!event.ctrlKey && expectedWidth > this.$userControl.width()){   // Why  allowance of 5 required??
                        this.options.lengthLimitVisible = false;
                        event.preventDefault();
                        return false;
                    }
                }
            } else if (this.options.multiLine && this.options.hScrollDisabled) {  // LC-4656 : wait till user input, if it causes an overflow revert to old text
                var $textArea = this.$userControl;
                $textArea.css("padding", "0px 0px 0px");  // TODO : take care of multiline selection & padding later

                // TODO : find a scheme to avoid attaching and detaching listeners, currently $.val() causes 'input' to fire, resulting in an infinite loop
                $textArea.one("input", function () {
                    if ($textArea.prop('scrollHeight') > $textArea.prop('offsetHeight')) {
                        $textArea.val(val)
                                 .prop("selectionStart", selectionEnd)
                                 .prop("selectionEnd", selectionEnd);  // LC-4656 : reset the cursor pos, afterwards
                        character = null;
                        code = 0;
                    }
                });
            }

            if (!_.contains(['keydown', 'cut'], event.type) && this._maxCharsReached(val) && selectionStart === selectionEnd) {
                event.preventDefault();
                return false;
            }

            this.$userControl.trigger({
                type : "onKeyInput.textField",
                originalType : event.type,
                character : character,  // contains the pasted string or pressed key
                keyCode : event.keyCode || 0,
                charCode : event.charCode || 0,
                which : event.which || 0,
                ctrlKey : event.ctrlKey || event.metaKey || false,
                shiftKey : event.shiftKey || false,
                keyDown: false, // This property is available only for list boxes and drop-down lists
                selectionStart: selectionStart,
                selectionEnd: selectionEnd
            });
        },

        _handleKeyDown : function(event){
            if (event) {
                var code = event.charCode || event.which || event.keyCode || 0;
                if(code == 8 || code == 46) // backspace and del
                   this._handleKeyInput(event, "", code);
            }
        },

        _handleKeyPress : function(event){
            if (event) {
                var code = event.charCode || event.which || event.keyCode || 0,
                    character = (code == 13) ? "\n" : String.fromCharCode(code); // modified '\r\n' -> '\n'

            if(xfalib.ut.XfaUtil.prototype.isNonPrintableKey(event.key)) { // mozilla also generates a keypress, along with keydown
                return true;                                               // for all keys, so only handling printable keys in keypress
            }

            this._handleKeyInput(event, character, code);
            }
        },

        _compositionUpdateCallback : function (event) {
            var that = this;
            var val = that.$userControl.val();
            if (event.type === "compositionupdate" && event.originalEvent.data) {
                // this has been deliberately done to get the actual data in case of max character.
                if (that.options.maxChars) {
                    val = event.originalEvent.data;
                } else {
                    val = val + event.originalEvent.data.substr(event.originalEvent.data.length - 1);
                }
            }
            var flag = that._maxCharsReached(val);
            if (flag) {
                // if max reached
                var newVal = val.substr(0, that.options.maxChars);
                //in case the value is not changed then we do not need to update value and close the android keyboard.
                if (val === newVal) {
                    return false;
                }
                that.$userControl.val(newVal);
            }
            return flag;
        },

        _attachEventHandlers: function($control) {
            $.xfaWidget.defaultWidget.prototype._attachEventHandlers.apply(this, arguments);
            // IME specific handling, to handle japanese languages max limit
            $.xfaWidget.defaultWidget.prototype._attachCompositionEventHandlers.apply(this, arguments);
        },

        _handlePaste : function(event){
            if (event) {
                var pastedChar = undefined;
                if (window.clipboardData && window.clipboardData.getData) { // IE
                    pastedChar = window.clipboardData.getData('Text');
                } else if (event.originalEvent.clipboardData && event.originalEvent.clipboardData.getData) {
                    pastedChar = event.originalEvent.clipboardData.getData('text/plain');
                }
                if(pastedChar) {
                    this._handleKeyInput(event, pastedChar, 0);
                }
            }
        },

        _handleCut : function(event) {
            if (event) {
                this._handleKeyInput(event, "", 0);
            }
        },

        postProcessExit: function(evnt) {
            $.xfaWidget.defaultWidget.prototype.postProcessExit.apply(this,arguments);
            if (this.options.multiLine && this.options.hScrollDisabled) {
                return;
            }
            this._handleVAlignOnExit();
        },

        preProcessEnter: function(evnt) {
            $.xfaWidget.defaultWidget.prototype.preProcessEnter.apply(this,arguments);
            if(this.options.multiLine && this.options.hScrollDisabled)
                return;
            this._handleVAlignOnEnter();
        },

        /**
         * @brief: Select the given field on focus in Internet Explorer
         *
         */
        _selectOnFocusInIE : function(){
            // if the value is not same only then do selection in IE
            // For Issue: LC-9895, we check if value not same
            if($.browser.msie && !this._isValueSame()) {
                this.$userControl.select();
            }
            else {
                //all other browsers behave like a good boy
            }
        },

        showValue : function() {
            $.xfaWidget.defaultWidget.prototype.showValue.apply(this,arguments);
            //IE doesn't show selected text if we focus and set its value all the time so force selection
            this._selectOnFocusInIE();
        },

        getCommitValue: function() {
            var value = $.xfaWidget.defaultWidget.prototype.getCommitValue.apply(this, arguments);

            if(this._maxCharsReached(value)) {
                value = value.slice(0,this.options.maxChars);
            }

            this.$userControl.val(this.options.value);

            //TODO: ask Sharad whether it is right
            if(this.options.multiLine && this.options.hScrollDisabled)  {
                //var str= this._checkLines(value);
                //if(value != str) {
                    return value;
                //}
            }
            return value;
        },

        /*
        ** returns the contentHeight which needs to be considered for padding for valign,
        ** if no contentHeight is present then fontSize is returned.
        */
        _getContentHeight: function () {
            var contentHeight = Math.ceil(this.$userControl.get(0).scrollHeight);
            return contentHeight ? contentHeight : this.options.fontSize;
        }
    });
})($, window._);
/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2019 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/

(function ($) {
    $.widget("xfaWidget.richTextField", $.xfaWidget.textField, {

        _widgetName : "richTextField",

        _richTextWidget : null,

        _changeAccess : function (val) {
            switch (val) {
                case "open":
                    if (this._richTextWidget) {
                        this._richTextWidget.editor.enable();
                        this._richTextWidget.$toolbar.removeClass("hideToolbar");
                    }
                    break;
                case "readOnly":
                    if (this._richTextWidget) {
                        this._richTextWidget.editor.disable();
                        this._richTextWidget.$toolbar.addClass("hideToolbar");
                    }
                    break;
            }
        },

        getOptionsMap : function () {
            var parentOptionsMap = $.xfaWidget.textField.prototype.getOptionsMap.apply(this, arguments);
            return $.extend({}, parentOptionsMap, {
                "value" : function (val) {
                    if (this._richTextWidget) {
                        this._richTextWidget.setRichTextEditorContent(val);
                    }
                },
                "access" : function (val) {
                    this._changeAccess(val);
                }
            });
        },

        getEventMap : function () {
            // in case of IE browsers, focus event is delayed, hence adding activate method for content editable
            if (xfalib.ut.XfaUtil.prototype.isIE()) {
                var parentOptionsMap = $.xfaWidget.textField.prototype.getEventMap.apply(this, arguments);
                return $.extend({}, parentOptionsMap, {
                    "activate.richTextField" : xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT
                });
            } else {
                return $.xfaWidget.textField.prototype.getEventMap.apply(this, arguments);
            }
        },

        render : function () {
            var $richTextWidget = this.element.find("div.richTextWidget").eq(0);
            if(!$richTextWidget.length){
                var attachedTextareaClasses = this.element.children().attr('class');
                var richTextWidgetElement = '<div class="richTextWidget ' + attachedTextareaClasses + '" id="richTextField_' + this.options.name + '_' + attachedTextareaClasses + '"></div>';
                this.element.children().remove();
                this.element.append(richTextWidgetElement);
                $richTextWidget = this.element.find("div.richTextWidget").eq(0);
            }else{
                $richTextWidget.children().remove();
            }
            $richTextWidget.append(this.options.value);
            return $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
        },

        getCommitValue : function () {
            var value = "";
            if (this._richTextWidget) {
                value = this._richTextWidget.getRichTextEditorContent();
            }
            return value;
        },

        preProcessEnter : function (evnt) {
            $.xfaWidget.textField.prototype.preProcessEnter.apply(this, arguments);
            var $richTextDiv = this.$userControl.find("div.richTextWidget").eq(0);
            if(!$richTextDiv.length){
                $richTextDiv = this.element.find("div.richTextWidget").eq(0);
                this.changeDefaultToolbarConfig();
                this.$userControl.parents('.richtextsupport').css('z-index', 'auto');
            }
            if (window.Form === undefined || window.Form.rte === undefined) {
                /* Forms RTE is part of Forms Addon package only. Dont do anything if addon is not installed.*/
                return;
            } else if (this._richTextWidget === null) {
                this._initializeRTEToolbar();
                this._richTextWidget = new window.Form.rte.RichTextEditor({
                    selector : $richTextDiv.attr("id"),
                    toolbar : window.Form.rte.RichTextEditor.MFToolbar,
                    data : this.options.value,
                    locale : $richTextDiv.data("locale")
                });
                var that = this;
                this._richTextWidget.editor.on("blur:composer", function () {
                    that.$userControl.trigger("blur");
                });
                // initialize the access
                if (this.options.access) {
                    this._changeAccess(this.options.access);
                }
            }
        },

        changeDefaultToolbarConfig: function(){
            if(window.Form && window.Form.rte){
                var toolbarDefaultConfigData = window.Form.rte.DefaultConfig;
                toolbarDefaultConfigData.fontSize.defaultValue = this.options.fontSize;
                toolbarDefaultConfigData.fontFamily.defaultValue = this.options.fontFamily;

                // Adding 'isFontInPx' flag and overriding two utility functions
                // 'getDefaultParaStyle' and 'getMissingParaStyle' are responsible for adding RTE font styling attributes to rich text elements
                toolbarDefaultConfigData.isFontInPx = true;
                this.changeDefaultParaStyleUtility();
                this.changeMissingParaStyleUtility();

                // Adding dropdown values in default config if not available in options
                if(toolbarDefaultConfigData.fontSize.options.indexOf(this.options.fontSize) === -1){
                    toolbarDefaultConfigData.fontSize.options.push(this.options.fontSize);
                }
                if(toolbarDefaultConfigData.fontFamily.options.indexOf(this.options.fontFamily) === -1){
                    toolbarDefaultConfigData.fontFamily.options.push(this.options.fontFamily);
                }
            }
        },

        changeDefaultParaStyleUtility: function(){
            Form.rte.util.HtmlUtils.getDefaultParaStyle = function (config) {
                var style = "";
                if (config) {
                    style += 'font-family:' + config.fontFamily.defaultValue + ';';
                    if(config.isFontInPx){
                        style += 'font-size:' + config.fontSize.defaultValue + 'px;';
                        style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'px;';
                    }else{
                        style += 'font-size:' + config.fontSize.defaultValue + 'pt;';
                        style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'pt;';
                    }
                    style += 'color:#000000;';
                    style += 'text-align:left;';
                }

                return style;
            };
        },

        changeMissingParaStyleUtility : function(){
            Form.rte.util.HtmlUtils.getMissingParaStyle = function (style, config) {
                if (style && style.length > 0) {
                    if (config) {
                        if (!Form.rte.util.StringHelper.endsWith(style, ";")) {
                            style += ";";
                        }
                        if (style.indexOf("font-family") < 0) {
                            style += 'font-family:' + config.fontFamily.defaultValue + ';';
                        }
                        if (style.indexOf("font-size") < 0) {
                            if(config.isFontInPx){
                                style += 'font-size:' + config.fontSize.defaultValue + 'px;';
                            }else{
                                style += 'font-size:' + config.fontSize.defaultValue + 'pt;';
                            }
                        }
                        if (style.indexOf("letter-spacing") < 0) {
                            if(config.isFontInPx){
                                style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'px;';
                            }else{
                                style += 'letter-spacing:' + config.letterSpacing.defaultValue + 'pt;';
                            }
                        }
                        if (style.indexOf("color") < 0) {
                            style += 'color:#000000;';
                        }
                        if (style.indexOf("text-align") < 0) {
                            style += 'text-align:left;';
                        }
                    }
                } else {
                    style = Form.rte.util.HtmlUtils.getDefaultParaStyle(config);
                }
                return style;
            };
        },

        _initializeRTEToolbar : function () {
            window.Form.rte.RichTextEditor.MFToolbar = window.Form.rte.RichTextEditor.MFToolbar || {
                defaultMode : 'basic',
                toolbars : {
                    basic : {
                        layout : [
                            {
                                items : [Form.rte.Commands.HEADER]
                            },
                            {
                                items : [Form.rte.Commands.BOLD, Form.rte.Commands.ITALIC, Form.rte.Commands.UNDERLINE]
                            },
                            {
                                command : 'lists',
                                icon : 'list',
                                title : "List Type",
                                type : 'popover',
                                placement : 'bottom',
                                items : [Form.rte.Commands.INSERT_UNORDERED_LIST,
                                    Form.rte.Commands.INSERT_ORDERED_LIST,
                                    Form.rte.Commands.INSERT_LOWERCASE_ALPHABET_LIST]
                            },
                            {
                                title : 'Expand',
                                command : Form.rte.Commands.MODE,
                                value : Form.rte.ToolbarMode.FULL,
                                icon : 'resize-full'
                            }
                        ],
                        floating : true
                    },
                    full : {
                        layout : [
                            {
                                items : [Form.rte.Commands.BOLD, Form.rte.Commands.ITALIC, Form.rte.Commands.UNDERLINE]
                            },
                            {
                                items : [Form.rte.Commands.SUPERSCRIPT, Form.rte.Commands.SUBSCRIPT]
                            },
                            {
                                items : [
                                    Form.rte.Commands.HEADER, Form.rte.Commands.FONT_FAMILY, Form.rte.Commands.LINE_HEIGHT, Form.rte.Commands.FORE_COLOR, Form.rte.Commands.HILITE_COLOR, Form.rte.Commands.LINK
                                ]
                            },
                            {
                                items : [Form.rte.Commands.INSERT_UNORDERED_LIST, Form.rte.Commands.INSERT_ORDERED_LIST, Form.rte.Commands.INSERT_LOWERCASE_ALPHABET_LIST
                                ]
                            },
                            {
                                title : 'Collapse',
                                command : Form.rte.Commands.MODE,
                                value : Form.rte.ToolbarMode.BASIC,
                                icon : 'resize-small',
                                selected : true
                            }
                        ]
                    }
                }
            };
        }
    });

})($);(function($){
	$.widget( "xfaWidget.imageField", $.xfaWidget.defaultWidget, {

    _widgetName:"imageField",

    options: {
        tabIndex: 0,
        "role": "img"
    },

    getEventMap: function () {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this, arguments);
        return $.extend({}, parentOptionsMap, {
            "imagechange": xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT
        })
    },

    getOptionsMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "screenReaderText": function(val) {
                if(val)
                    this.$userControl.attr("alt", val)
            },
            "displayValue": function(val) {
                var widgetValue;
                if (this.options.value) {
                    widgetValue = "data:;base64," + this.options.value;
                } else {
                    widgetValue = "";
                }
                this.$userControl.prop(this.options.commitProperty, widgetValue);
                this.$userControl.attr(this.options.commitProperty, widgetValue);
            },
            "access" : function() {},

            // CQ-85514 : use max-ht & max-wd to honor image's intrinsic ht & wd attributes & prevent distortion
            "height" : function (val) {
                // in case aspect is actual then we need to crop the image, which will be not possible if max height and width are set
                if (val && this.options.aspect != "actual") {
                    this.$css(this.$userControl[0], {"max-height": val});
                }
            },
            "width" : function (val) {
                if (val && this.options.aspect != "actual") {
                    this.$css(this.$userControl[0], {"max-width": val});
                }
            },
            "aspect" : function (val) {
                // value of actual turns off scaling, causing the image to be drawn at its native size,
                // as per xfa spec Adobe implementations crop the image
                if(this.options.aspect == "actual") {
                    var right = this.$userControl.attr("width"),
                        bottom = this.$userControl.attr("height");
                    right = right.indexOf("px") >= 0 ? right : right + "px";
                    bottom = bottom.indexOf("px") >= 0 ? bottom : bottom + "px";
                    this._cropImage("0px", right, bottom, "0px");
                    this.$userControl.removeAttr("height width");
                // value of none indicates no aspect ratio
                // as per xfa spec image is independently scaled in the horizontal and vertical directions to exactly fill the field,
                // which are already set to fill the field
                } else if (this.options.aspect != "none") {
                // A value of fit, which is the default, causes the scale to be such that the image fills as much of the field as possible
                // without overflowing it in either dimension.
                    this.$userControl.attr({"height" : "auto", "width" : "auto"});
                }
            }
        });
    },

    // crop the image using top,right, bottom, left coordiantes of the image
    _cropImage : function (top, right, bottom, left) {
        var clipRect = "rect(" + top + "," + right + "," + bottom + "," + left + ")";
        var clipPathPolygon = "polygon( 0px 0px, 0px " + bottom + "," + right + " " + bottom +"," + right + " 0px)";
        // clip property is deprecated but still supported by all the major browsers
        // clip-path replaces the deprecated clip property but still is not fully supported by all major browser
        this.$userControl.css({"clip" : clipRect, "clip-path" : clipPathPolygon});
    },

    render : function() {
        var self = this;
        if (typeof FileReader !== "undefined") {
            this.reader = new FileReader();
        } else {
            xfalib.ut.XfaUtil.prototype.getLogger().error("Image Field is supported only for HTML5 supported browsers.");
        }
        if (this.element) {
            // change event triggered when new image is selected
            this.$widgetInput = this.element.find("input").on("change.imageField", function() {
                self._handleInputChange();
            }).click(function(event) {
                // to stop bubbling of event from input to widget
                event.stopPropagation();
            });
            this.$widgetImg = this.element.on("click.imageField", function() {
                self._imageClick();
            }).find("img");
        }
        if (this.reader) {
            //load event is triggered each time the reading operation is successfully completed
            this.reader.addEventListener("load", function () {
                self.$widgetImg.attr("src",self.reader.result);
                self.$widgetImg.trigger("imagechange");
            }, false);
        }
        return $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
    },

    getCommitValue: function() {
        return this._extractData(this.$userControl.attr("src"));
    },

    // hidden input change handler, input change will be triggered on selecting a new image
    _handleInputChange : function() {
        this._displayImage();
    },

    _imageClick : function(clickEvent) {
        //as the input button is hidden we trigger click explicitly on click of the widget
        this.$widgetInput.trigger("click");
    },

    // removes "data\:.*\;base64," from the image base64 string
    _extractData : function(value) {
        return value.replace(/data\:.*\;base64,/, "");
    },

    // previews image in the imagefield widget
    _displayImage : function() {
        var imageFile = this.$widgetInput.get(0).files ? this.$widgetInput.get(0).files[0] : null;
        if (imageFile && this._isFileOfImageType(imageFile.name)) {
            if (this.reader) {
                //readAsDataURL method is used to read the contents of the specified file, result attribute contains  the data as a URL representing the file's data as a base64 encoded string
                this.reader.readAsDataURL(imageFile);
            }
        }
    },

    // Test for supported image file(jpg,jpeg,png,gif,tif,bmp)
    _isFileOfImageType : function(fileName) {
        if (fileName) {
            return (/\.(jpe?g|png|gif|tif|bmp)$/i.test(fileName));
        }
        return false;
    }
});
})($);
/**
 * Created with IntelliJ IDEA.
 * User: rpandey
 * Date: 12/24/12
 * Time: 8:06 PM
 * To change this template use File | Settings | File Templates.
 */


(function($){
    $.widget( "xfaWidget.signatureField", $.xfaWidget.defaultWidget, {

        _widgetName:"signatureField",

        getOptionsMap: function() {
            var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
            return $.extend({},parentOptionsMap,{
                "displayValue": function(val) {},
                "access": function(val) {}
            })
        },

        render : function() {
            var $control = $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments);
            //pessimistic checks
            if($control) {
                $control.attr("readOnly","readonly").attr("disabled", true);
            }
            return $control;
        }
    });
})($);
/*
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 * Copyright 2011-2012 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 */
 
/**
 * widget definition for scribbleable field
 */
(function($,xfalib){

 var TouchUtil=xfalib.ut.TouchUtil;
 var ScribbleUtil=(function(){
      return {
          localeString:function(id){
                    return xfalib.ut.XfaUtil.prototype.encodeScriptableTags($.xfaWidget.abstractWidget.prototype.localeStrings()[id])  || id;
          }
      };
 })();
 var DELETE_KEY = 46;
 var ESC_KEY = 27;
 var ENTER_KEY = 13;
/**
 * Scribble class definition, used for drawing on canvas using mouse or touch
 */
function Scribble( canvasID,image,_width,_height, callback) {
    this._callback = callback;
    this.canvasID = canvasID;
    this._lineWidth=5;
    this.canvas = $("#"+canvasID);
    this.context = this.canvas.get(0).getContext("2d"); 
    this.context.clearRect(0,0,this.canvas.width,this.canvas.height);
    this._enabled=true;
    this.context.strokeStyle = "#000000";
    this.canvasBorderWidth = parseInt(this.canvas.css('border-left-width'),10); // assuming top and left borders are same width
    this.context.lineWidth = this._lineWidth;
    this.lastMousePoint = {x:0, y:0};
    
    this.canvas[0].width = _width;// this.canvas.parent().innerWidth();
    this.canvas[0].height = _height;//this.canvas.parent().innerHeight();
    if(!image){
        this.context.fillStyle   = '#ffffff';
        this.context.clearRect(0,0,_width,_height);
    } else {
        this.context.drawImage(image,0,0);
    }
    this.canvas.on( TouchUtil.POINTER_DOWN, this.onCanvasMouseDown() );
}
Scribble.prototype.setLineWidth=function(w){
    this._lineWidth=w;
};
Scribble.prototype.onCanvasMouseDown = function () {
    var self = this;
    return function(event) {
        if(TouchUtil.getTouches(event).length < 2){
            self.mouseMoveHandler = self.onCanvasMouseMove();
            self.mouseUpHandler = self.onCanvasMouseUp();
            //CQ-4261765 : Scribble sign scroll issue with ios
            //https://stackoverflow.com/questions/49500339/cant-prevent-touchmove-from-scrolling-window-on-ios
            //https://github.com/jquery/jquery/issues/2871
            document.addEventListener(TouchUtil.POINTER_MOVE, self.mouseMoveHandler,{ passive: false });
            $(document).on(TouchUtil.POINTER_UP, self.mouseUpHandler );
            self.updateMousePosition( event );
            self.updateCanvas( event );
        }
    }
};

Scribble.prototype.onCanvasMouseMove = function () {
    var self = this;
    return function(event) {
        if(TouchUtil.getTouches(event).length < 2){
            self.updateCanvas( event );
            event.preventDefault();
            return false;
        }
    }
};

Scribble.prototype.onCanvasMouseUp = function (event) {
    var self = this;
    return function(event) {
        document.removeEventListener(TouchUtil.POINTER_MOVE, self.mouseMoveHandler,{ passive: false });
        $(document).off(TouchUtil.POINTER_UP, self.mouseUpHandler );
        self.mouseMoveHandler = null;
        self.mouseUpHandler = null;
    }
};

Scribble.prototype.updateMousePosition = function (event) {
    if(!this._enabled) return ;
    var target = TouchUtil.getTouchEvent(event);

    var offset = this.canvas.offset();
    /* In IE>=10 pageX values are incorrect when using zoom
     so calculate them using clientX and scrollLeft */
    this.lastMousePoint.x = target.clientX + $(window).scrollLeft() - offset.left - this.canvasBorderWidth;
    this.lastMousePoint.y = target.clientY + $(window).scrollTop() - offset.top - this.canvasBorderWidth;

};
Scribble.prototype._isInsideCanvas = function(x,y){
    return y>=0 && y<this.canvas[0].height && x>=0 && x < this.canvas[0].width;
};
    Scribble.prototype.updateCanvas = function (event) {
    if(!this._enabled) {
       return;
    }
    var oldX,oldY,dX,dY,canDraw,scaleX,scaleY,cssWidth,cssHeight;
    cssWidth = parseInt(this.canvas[0].style.width,10);
    cssHeight = parseInt(this.canvas[0].style.height,10);
    scaleX =  cssWidth?this.canvas[0].width/cssWidth:1;
    scaleY = cssHeight?this.canvas[0].height/cssHeight:1;

    scaleX /= xfalib.ut.XfaUtil.prototype.formScaleFactor;
    scaleY /= xfalib.ut.XfaUtil.prototype.formScaleFactor;

    oldX = this.lastMousePoint.x*scaleX;
    oldY = this.lastMousePoint.y*scaleY;
   
    this.updateMousePosition( event );

    var newX =  this.lastMousePoint.x*scaleX;
    var newY =  this.lastMousePoint.y*scaleY;

    dX = Math.abs(newX - oldX );
    dY = Math.abs(newY - oldY );

    canDraw = ( dX > 0 || dY > 0 ) && this._isInsideCanvas(oldX,oldY) && this._isInsideCanvas(newX,newY);;

    if(canDraw){
        this.context.beginPath();
        this.context.moveTo( oldX, oldY );
        this.context.lineTo(newX, newY );
        this.context.lineWidth=this._lineWidth;
        this.context.lineCap='round';
        this.context.stroke();
		
        this._callback();
		
    }
};

Scribble.prototype.toString = function () {

    var dataString = this.canvas.get(0).toDataURL("image/png");
    //var index = dataString.indexOf( "," )+1;
    //dataString = dataString.substring( index );

    return dataString;
};
Scribble.prototype.setEnabled=function(enable){
    this._enabled=enable;
};
Scribble.prototype.clear = function () {

    var c = this.canvas[0];
    this.context.clearRect( 0, 0, c.width, c.height );
};


// ImageEdit dialog box
var imageEditDialog=(function(_){
  
    // html used to construct dialog box
    var htmlStr=(function(){
         var html=[
             '<div id="iEBox_container" tabindex="0" role="dialog" aria-label="'+ScribbleUtil.localeString("pleaseSignText")+'">',
                  '<div id="iEBox_panel">',
                      '<div  id = "iEBox_Cancel" class="iEBox_button" tabindex="0" role="button" aria-label="'+ScribbleUtil.localeString("cancel")+'" title="'+ScribbleUtil.localeString("cancel")+'" ></div>',
                  '</div>',
                  '<div id="iEBox_content">',
                      '<div id="iEBox_canvases" align=center>',
                          '<div style="display:inline-block; vertical-align:top;">',
                               '<canvas  id="iEBox_canvas" style="margin:0px;border-bottom:0px;" width="696" height="390" ></canvas>' ,
                               '<input type="text" id="keyboard_Sign_Box" name="signatureText" placeholder="'+ScribbleUtil.localeString("typeYourSignatureHere")+'">',
                               '<fieldset id="iEBox_caption"><legend align="center">'+ScribbleUtil.localeString("pleaseSignText")+'</legend></fieldset>',
                          '</div>',
                          '<canvas id="iEBox_geoCanvasRight" width="0" height="0" ></canvas>',
                          '<div><canvas id="iEBox_geoCanvasBottom" width="0" height="0" ></canvas></div>',
                      '</div>',
                      '<div>',
                          '<div id="iEBox_Brush" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("brushes")+'"  title="'+ScribbleUtil.localeString("brushes")+'"></div>',
                          '<div id="iEBox_Clear" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("clear")+'"  title="'+ScribbleUtil.localeString("clear")+'" ></div>',
                          '<div id="iEBox_Geo" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("geolocation")+'"  title="'+ScribbleUtil.localeString("geolocation")+'" ></div>',
                          '<div id="iEBox_Text" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("typeYourName")+'"  title="'+ScribbleUtil.localeString("typeYourName")+'"></div>',
                          '<div id="iEBox_title"></div>',
                          '<div id="iEBox_Ok" class="iEBox_button" tabindex="0"  role="button" aria-label="'+ScribbleUtil.localeString("ok")+'"  title="'+ScribbleUtil.localeString("ok")+'" ></div>',
                      '</div>' ,
                  '</div>' ,
                  '<div id="iEBox_moveframe" ></div>',
                  '<div id="iEBox_brushList" ></div>',
              '</div>'].join("");
           return function(){
              return html;
           };
    });
	
    /**
	 *   
	 */
	
    var dialogObj = {
        verticalOffset: 0, // removing the magic value of -75 since it was not causing any impact
        horizontalOffset: 0,
        repositionOnResize: true,
        overlayOpacity: .75,
        overlayColor: '#CCCCCC',
        draggable: true,
        _brushes:[2,3,4,5,6,7,8,9,10],
		_buttonsEnabled:{},
		_isOpen:false,
        show:function(title,callback){
           this._show(callback);
		   this._buttonsEnabled={Geo:true,Clear:true,Ok:true,Cancel:true,Brush:true,Text:true};
        },
		setEnabled:function(button,enable){
		    if(this._buttonsEnabled[button]!=enable){
		           this._buttonsEnabled[button]=enable;
				   if(enable){
				       $('#iEBox_'+button).empty('<div style="background:white;width:100%;height:100%;opacity:0.75;"></div>').
				                  removeClass("disable_button");
				   } else {
				       $('#iEBox_'+button).append('<div style="background:white;width:100%;height:100%;opacity:0.75;"></div>').
				                  addClass("disable_button");
				   }
			       
			}
		},
		enableButtons:function(buttons){
		    for(var k in buttons){
				   this.setEnabled(k,buttons[k]);
			}
		},
        toggleBrushList:function(event){
                var that = this;
                if($('#iEBox_brushList').css('display')!='none'){
                    $('#iEBox_brushList').css({display:'none'});
                    return;
                }
                 var tmpFn =  document.onselectstart;
                 document.onselectstart=function(){return false;};
                 $('#iEBox_brushList').css({display:'block',visibility:'hidden'});
                    $('#iEBox_brushList').offset($('#iEBox_Brush').offset());
                    $('#iEBox_brushList').offset({top:$('#iEBox_Brush').offset().top-$('#iEBox_brushList').height()});
                    $('#iEBox_brushList').css({display:'block',visibility:'visible'});
                  //  $('#iEBox_brushList').focus();
                     $('#iEBox_brushList').one('mouseleave',function(event){
                         $('#iEBox_brushList').css({display:'none'});
                          document.onselectstart=tmpFn;
                     });
        },
        _attachCallbacks: function(callback) {
            var that = this;
            var sigCanvas = $('#iEBox_canvas')[0];
            var ctx=sigCanvas.getContext("2d");
            var minSigCanvasFontSize=10;
            var maxSigCanvasFontSize=70;
            var sigCanvasFontSize=minSigCanvasFontSize;
            var initialSigCanvasFontSize=sigCanvasFontSize;
            var initialFontCalculatedFlag=false;
            var sigCanvasFontFamily="sans-serif, Georgia";
            var sigCanvasFontStyle="italic";
           _.each("Cancel-Clear-Geo-Ok-Brush-Text".split("-"),function(val,idx){
                    $("#iEBox_"+val).click( function(event) {
				       if(that._buttonsEnabled[val]){
                          event.stopPropagation();
                          callback(val);
				       }
                    });
					$("#iEBox_"+val).keydown( function(event) {
				       if(that._buttonsEnabled[val] && (event.keyCode == ENTER_KEY || event.charCode == ENTER_KEY || event.which == ENTER_KEY) ){
                          event.stopPropagation();
                          callback(val);
				       }
                    });
            });
            _.each($("#iEBox_brushList").children(),function(itm,idx){
                  $(itm).on(TouchUtil.POINTER_UP,function(event){
                         callback("BrushSelect",that._brushes[idx]);
                         $('#iEBox_brushList').css({display:'none'});
                          // $(itm).css({backgroundColor:'#FFFFFF'});
                  });
                  $(itm).on(TouchUtil.POINTER_DOWN,function(event){
                          // $(itm).css({backgroundColor:'#AAAAAA'});
                           event.preventDefault();
                  });
             });

            $('#keyboard_Sign_Box').keydown(function (event){
                var inputSign=$('#keyboard_Sign_Box')[0].value;

                if(event.key==="Backspace") {
                    ctx.font=sigCanvasFontStyle+sigCanvasFontSize+"px "+sigCanvasFontFamily;
                    sigCanvasFontSize=dialogObj._increaseFontForSignature(ctx.measureText(inputSign).width,sigCanvas.width,
                        sigCanvasFontSize,initialSigCanvasFontSize);
                    ctx.font=sigCanvasFontStyle+" "+sigCanvasFontSize+"px "+sigCanvasFontFamily;
                    ctx.clearRect(0, 0, sigCanvas.width, sigCanvas.height);
                    ctx.fillText(inputSign, 3, sigCanvasFontSize, sigCanvas.width-5);
                }
                event.stopPropagation();
            });

            $("#keyboard_Sign_Box").keyup(function (event){
                var inputSign=$('#keyboard_Sign_Box')[0].value;
                if(inputSign.length==0) {
                    dialogObj.enableButtons({Ok: false, Clear: false});
                }
                if(inputSign.length>=1 && inputSign.trim().length!=0) {
                    dialogObj.enableButtons({Ok: true, Clear: true});
                }
                if(initialFontCalculatedFlag===false){
                    sigCanvasFontSize=sigCanvas.height-20;
                    sigCanvasFontSize=sigCanvasFontSize<minSigCanvasFontSize?minSigCanvasFontSize:sigCanvasFontSize;
                    sigCanvasFontSize=sigCanvasFontSize>maxSigCanvasFontSize?maxSigCanvasFontSize:sigCanvasFontSize;
                    initialSigCanvasFontSize=sigCanvasFontSize;
                    $('#keyboard_Sign_Box')[0].style.font=sigCanvasFontStyle+" 2rem "+sigCanvasFontFamily;
                    initialFontCalculatedFlag=true;
                }
                ctx.font=sigCanvasFontStyle+sigCanvasFontSize+"px "+sigCanvasFontFamily;
                sigCanvasFontSize=dialogObj._decreaseFontForSignature(ctx,inputSign,sigCanvas.width,
                    sigCanvasFontSize,sigCanvasFontFamily);
                ctx.font=sigCanvasFontStyle+" "+sigCanvasFontSize+"px "+sigCanvasFontFamily;
                ctx.clearRect(0, 0, sigCanvas.width, sigCanvas.height);
                ctx.fillText(inputSign,3,sigCanvasFontSize,sigCanvas.width-5);
                event.stopPropagation();
            });

            // capture tab key and escape
            $('#iEBox_container').keydown(function(event){
                var firstFocusableItem = document.querySelector("#iEBox_container");
                var lastFocusableItem = document.querySelector("#iEBox_Ok");
                var KEYCODE_TAB = 9;
                var isTabPressed = (event.key === 'Tab' || event.keyCode === KEYCODE_TAB);
                if((event.keyCode == ESC_KEY || event.charCode == ESC_KEY || event.which == ESC_KEY)) {
                    event.stopPropagation();
                    event.preventDefault();
                    callback("Cancel");
                } else if (isTabPressed) {
                    // Trap focus inside the dialog box
                    if (event.shiftKey && document.activeElement === firstFocusableItem) {
                        // when shift + tab key is pressed
                        lastFocusableItem.focus();
                        event.preventDefault();
                    } else if (document.activeElement === lastFocusableItem) {
                        // when tab key is pressed
                        firstFocusableItem.focus();
                        event.preventDefault();
                    }
                }

            });

            if(this.draggable){
                this._makeDraggable(TouchUtil.TOUCH_ENABLED);
            }
        },

        _decreaseFontForSignature:function(ctx,inputSign,sigCanvasWidth,fontSize,sigCanvasFontFamily){
            while(ctx.measureText(inputSign).width>sigCanvasWidth-5 && fontSize>20){
                fontSize=fontSize-10;
                ctx.font=fontSize+"px "+sigCanvasFontFamily;
            }
            return fontSize
        },
        _increaseFontForSignature:function(textWidth,sigCanvasWidth,fontSize,initialSigCanvasFontSize){
            if(sigCanvasWidth-textWidth>0){
                fontSize=initialSigCanvasFontSize;
            }
            return fontSize;
        },
        _makeDraggable:function(touchEnabled){
              var _isMouseDown=false;
              var _that=this;
              var dX;
              var dY;
              var offsetPos;
              var _mouseMovFun;
              var _mouseUpFun;
              $('#iEBox_panel').on(TouchUtil.POINTER_DOWN,function( event ){
              
                  if(TouchUtil.getTouches(event).length < 2){
                      if($(event.target).is('#iEBox_panel')){
                          $('body')[0].addEventListener(TouchUtil.POINTER_MOVE,_mouseMovFun=function( event ){
                              if(TouchUtil.getTouches(event).length < 2 && _isMouseDown){
                                  event.preventDefault();
                                  var evt = TouchUtil.getTouchEvent(event);
                                  var delX = evt.pageX - dX;
                                  var delY = evt.pageY - dY;
                                  $('#iEBox_moveframe').offset({
                                      top: offsetPos.top+delY,
                                      left: offsetPos.left+delX
                                  });
                              }
                          }, { passive: false });
                          $('body').on(TouchUtil.POINTER_UP,_mouseUpFun=function(event){
                              if(_isMouseDown){
                                  var offsetMove = $('#iEBox_moveframe').offset();
                                  var topEdge  = $(window).scrollTop();
                                  var bottomEdge = topEdge + $(window).height();
                                  if(offsetMove.top - topEdge < 1){
                                      offsetMove.top = topEdge;
                                  }
                                  if(offsetMove.top - bottomEdge + $('#iEBox_panel').height() > 0 ){
                                      offsetMove.top = bottomEdge - $('#iEBox_panel').height();
                                  }
                                  $('#iEBox_container').offset(offsetMove );
                                  $('#iEBox_moveframe').css({display:'none'}).offset(offsetMove);
                                  _isMouseDown=false;
                                  $('body')[0].removeEventListener(TouchUtil.POINTER_MOVE,_mouseMovFun,{ passive: false });
                                  $('body').off(TouchUtil.POINTER_UP,_mouseUpFun);
                              }
                          });

                          var evt = TouchUtil.getTouchEvent(event);
                          _isMouseDown=true; dX = evt.pageX;dY=evt.pageY;
                          offsetPos = $('#iEBox_container').offset();
                          $('#iEBox_moveframe').css({display:'block'});
                          $('#iEBox_moveframe').offset(offsetPos);
                          $('#iEBox_moveframe').css('width',$('#iEBox_container').css('width'));
                          $('#iEBox_moveframe').css('height',$('#iEBox_container').css('height'));
                      }
                  }
              });
             
        },
        _createBrushes:function(){
               var _that=this;
              _.each(this._brushes,function(val,idx){
                  var divel = document.createElement('DIV');
                  var cnv = document.createElement('CANVAS');
                  var ctx = cnv.getContext('2d');
                  cnv.style.border='1px solid #AAAAAA';
                  cnv.width=TouchUtil.TOUCH_ENABLED?200:100;
                  cnv.height=TouchUtil.TOUCH_ENABLED?40:20;;
                  ctx.lineWidth=val;
                  ctx.beginPath();
                  ctx.moveTo(10,cnv.height/2);
                  ctx.lineTo(cnv.width-10,cnv.height/2);
                  ctx.stroke();
                  divel.appendChild(cnv);
                  $('#iEBox_brushList').append(divel);
               });
        },
		getIsOpen:function(){
		    return dialogObj._isOpen;
		},
		setIsOpen:function(open){
		    dialogObj._isOpen = open;
		},
        _show: function(callback) {
            dialogObj.hide();
            dialogObj._overlay('show');
            
            $("BODY").append(htmlStr());
            dialogObj.setIsOpen(true);
            $('#iEBox_container').focus();
            dialogObj._createBrushes();

            dialogObj._reposition();

            // calculate spacing around canvas area
            // this will be used to find canvas dimensions based on available screen area.
            var container_el = $('#iEBox_container');
            var canvas_el =  $('#iEBox_canvas');
            var container_width = $('#iEBox_container').outerWidth(true);
            var container_height = $('#iEBox_container').outerHeight(true);
            var canvas_width = canvas_el[0].width;
            var canvas_height = canvas_el[0].height;
            dialogObj.canvas_spacing = { x:container_width - canvas_width, y:container_height-canvas_height};

            dialogObj._maintainPosition(true);
            
            dialogObj._attachCallbacks(callback);
        },

        hide: function() {
            $("#iEBox_container").remove();
            this._overlay('hide');
            dialogObj.setIsOpen(false);
            this._maintainPosition(false);
        },
        _overlayResize:function(event) {
            if($("#iEBox_overlay").height()!= $(document).height()){
                $("#iEBox_overlay").height( $(document).height() );
            }

        },
        _disableMove:function(event) {
            event.preventDefault();
        },
        _overlay: function(status) {
            switch( status ) {
                case 'show':
                    this._overlay('hide');
                    $("BODY").append('<div id="iEBox_overlay"></div>');
                    $("#iEBox_overlay").css({
                        position: 'fixed',
                        zIndex: 99997,
                        top: '0px',
                        left: '0px',
                        width: '100%',
                        height: $(document).height(),
                        background: this.overlayColor,
                        opacity: this.overlayOpacity
                    });
                    if(xfalib.ut.XfaUtil.prototype.isSafari()) {
                        $("#iEBox_overlay").on('touchmove', this._disableMove);
                    }
                    $(document).on('scroll',this._overlayResize);
                break;
                case 'hide':
                    if(xfalib.ut.XfaUtil.prototype.isSafari()) {
                        $("#iEBox_overlay").off('touchmove');
                    }
                    $("#iEBox_overlay").remove();
                    $(document).off('scroll',this._overlayResize);
                break;
            }
        },
        /**
         * resize dialog based on available screen area
         */
        _resize:function(){
            // available screen area
            var aWidth = $(window).width();
            var aHeight = $(window).height();

            var sigCnv = $('#iEBox_canvas')[0];
            var sigTextBox = $('#keyboard_Sign_Box')[0];
            var bGeoCnv = $('#iEBox_geoCanvasBottom')[0];
            var rGeoCnv = $('#iEBox_geoCanvasRight')[0];

            // calculate amount of width height we need to reduce

            var totalCnvWidth = sigCnv.width + rGeoCnv.width;
            var totalCnvHeight = sigCnv.height + bGeoCnv.height;





            var diffW = totalCnvWidth + dialogObj.canvas_spacing.x - aWidth;
            if(diffW < 0) {
                diffW = 0;
            }
            var diffH = totalCnvHeight + dialogObj.canvas_spacing.y - aHeight;
            if(diffH < 0){
                diffH = 0;
            }

            var newTotalCnvHeight, newTotalCnvWidth;
            if( diffW > 0 || diffH > 0 ){ // does any side need resize

                if(diffH * totalCnvWidth > totalCnvHeight * diffW){ // need to reduce height
                   newTotalCnvHeight = totalCnvHeight - diffH;
                   newTotalCnvWidth = (newTotalCnvHeight * totalCnvWidth)/ totalCnvHeight;
                } else {
                   newTotalCnvWidth = totalCnvWidth - diffW;
                   newTotalCnvHeight = (newTotalCnvWidth * totalCnvHeight)/ totalCnvWidth;
                }

                // distribute evenly the new dimensions


                var newSigCnvWidth   = (newTotalCnvWidth*sigCnv.width)/totalCnvWidth;
                var newSigCnvHeight = (newTotalCnvHeight*sigCnv.height)/totalCnvHeight;

                sigCnv.style.width = newSigCnvWidth + "px";
                sigCnv.style.height = newSigCnvHeight + "px";

                sigTextBox.style.width = newSigCnvWidth + "px";
                sigTextBox.style.height = newSigCnvHeight + "px";


                bGeoCnv.style.width = newSigCnvWidth +"px";
                bGeoCnv.style.height = (newTotalCnvHeight - newSigCnvHeight) +"px";

                rGeoCnv.style.width = (newTotalCnvWidth - newSigCnvWidth) +"px";
                rGeoCnv.style.height = newSigCnvHeight + "px";


                $('#iEBox_caption').width(Math.floor(newSigCnvWidth));

            } else {
                sigCnv.style.width =  sigCnv.width + "px";
                sigCnv.style.height = sigCnv.height + "px";

                sigTextBox.style.width =  sigCnv.width + "px";
                sigTextBox.style.height = sigCnv.height + "px";

                bGeoCnv.style.width =  bGeoCnv.width + "px";
                bGeoCnv.style.height = bGeoCnv.height + "px";

                rGeoCnv.style.width =  rGeoCnv.width + "px";
                rGeoCnv.style.height = rGeoCnv.height + "px";

                $('#iEBox_caption').width(sigCnv.width);

            }
        },
        _reposition: function() {
            var top = (($(window).height() * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) / 2) - ($("#iEBox_container").outerHeight() / 2)) + dialogObj.verticalOffset;
            var left = (($(window).width() * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) / 2) - ($("#iEBox_container").outerWidth() / 2)) + dialogObj.horizontalOffset;
            if( top < 0 ) top = 0;
            if( left < 0 ) left = 0;

            $("#iEBox_container").css({
                top: top + $(window).scrollTop() * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) + 'px',
                left: left + $(window).scrollLeft() * (1 / xfalib.ut.XfaUtil.prototype.formScaleFactor) + 'px'
            });
            $("#iEBox_container").focus();   // scroll up to the canvas
            $("#iEBox_overlay").height( $(document).height() );
        },
        _maintainDialog:function(){
            dialogObj._resize();
            dialogObj._reposition();
        },
        _maintainPosition: function(status) {
            if(dialogObj.repositionOnResize ) {
                switch(status) {
                    case true:
                        $(window).on('orientationchange', dialogObj._maintainDialog); // also reposition if device is tilted
                    break;
                    case false:
                        $(window).off('orientationchange', dialogObj._maintainDialog);
                    break;
                }
            }
        }
        
    };
    return dialogObj;
})(window._);

/**
 * class definition for GeoLocationQueryRequest
 * encapsulated success and error handlers 
 */
function GeoLocQuery(){}
GeoLocQuery.prototype={
    init:function(success,failure){
        this._successHandler = success;
        this._errorHandler = failure;
        this._active=true;
        return this;
    },
    _handleSuccess:function(data){
        this._successHandler(data); 
    },
    _handleError:function(err){
        this._errorHandler(err);   
    },
    query:function(){
         _that=this;
         navigator.geolocation.getCurrentPosition(function(pos){
          if(_that._active){
             _that._handleSuccess(pos);
          }
          _that._active=false;
       },function(err){
          if(_that._active){
             _that._handleError(err);
          }
          _that._active=false;
       },{timeout:10000});
    },
    cancel:function(){
        _that._active=false;
    }

};
// GeoLocQuery definition ends here

/**
*
*  Base64 encode / decode
*  http://www.webtoolkit.info/
*
**/
 
var Base64 = {
 
	// private property
	_keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
 
	// public method for encoding
	encode : function (input) {
		var output = "";
		var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
		var i = 0;
 
		while (i < input.length) {
 
			chr1 = input.charCodeAt(i++);
			chr2 = input.charCodeAt(i++);
			chr3 = input.charCodeAt(i++);
 
			enc1 = chr1 >> 2;
			enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
			enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
			enc4 = chr3 & 63;
 
			if (isNaN(chr2)) {
				enc3 = enc4 = 64;
			} else if (isNaN(chr3)) {
				enc4 = 64;
			}
 
			output = output +
			this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
			this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
 
		}
 
		return output;
	},
 
	// public method for decoding
	decode : function (input) {
		var output = "";
		var chr1, chr2, chr3;
		var enc1, enc2, enc3, enc4;
		var i = 0;
 
		input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
 
		while (i < input.length) {
 
			enc1 = this._keyStr.indexOf(input.charAt(i++));
			enc2 = this._keyStr.indexOf(input.charAt(i++));
			enc3 = this._keyStr.indexOf(input.charAt(i++));
			enc4 = this._keyStr.indexOf(input.charAt(i++));
 
			chr1 = (enc1 << 2) | (enc2 >> 4);
			chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
			chr3 = ((enc3 & 3) << 6) | enc4;
 
			output = output + String.fromCharCode(chr1);
 
			if (enc3 != 64) {
				output = output + String.fromCharCode(chr2);
			}
			if (enc4 != 64) {
				output = output + String.fromCharCode(chr3);
			}
 
		}
 
		return output;
 
	}
 
	
 
};

/**
 * Utility Singleton for handling PNG Data
 */
var PNGUtil=(function(){
    var slf={
   _LC_Scribble_MetaDataKey:"LC_SCIBBLE_METADATA",
           _isPng:function(b64data){
               return  b64data && b64data.replace(/\s+/g, "").indexOf("iVBORw0KGgo") == 0;   // LC-5711 : trim any leading WhiteSpace
               // TODO :  base64 encoding may have white spaces even between the magic numbers !! Think of a better way to stop stripping white spaces repeatedly in PNGUtil, and cache the result
           },
           _update_crc:function(crc,data){
               var c = crc;
               var n;
               for(n=0;n<data.length;n++){
                  c = this._XOR(slf._crc_table[(this._XOR(c,data.charCodeAt(n))&0xff)>>>0],(c>>>8));
               }
               return c;
           },
		   _XOR:function(a,b){
		       return (a^b)>>>0;
		   },
           _U32Int2Str:function(n){
                return String.fromCharCode((n>>>24)&0xFF)+String.fromCharCode((n>>>16)&0xFF)+String.fromCharCode((n>>>8)&0xFF)+String.fromCharCode(n>>>0&0xFF);
            },
           _init_crc_table:function(){
               var c=0;
               var n,k;
               slf._crc_table=[];
               for(n=0;n<256;n++){
                   c = n;
                   for(k=0;k<8;k++){
                      if(((c&1)>>>0)>0){
                          c = slf._XOR(0xedb88320 , (c>>>1));
                      } else {
                          c = c>>>1;
                      }
                   }
                   slf._crc_table[n]=c;
                }
           },
           _CRC:function(data){
                if(!this._crc_table) this._init_crc_table();
                return this._XOR(this._update_crc(0xffffffff,data) , 0xffffffff);
          },
          _prepareTextChunk:function(content,pad){
              // pad the data appropriately                      
               var len = content.length;
               var lenStr = slf._U32Int2Str(len);
               var chunkType="tEXt";
               var checkSumStr = slf._U32Int2Str(slf._CRC(chunkType+content));
               return lenStr+chunkType+content+checkSumStr;
           },
        _start:function(str){
           slf._startTime = new Date().getTime();
           slf._startFun=str;
        },
        _end:function(){
           var str = "Time "+slf._startFun+": "+(new Date().getTime()-slf._startTime);
          //  $('BODY').append("<p>"+str+"</p><br/>");
        },
        _readU32Int:function(ctx){
            var val=0;
            var d=ctx.d;
            val=((d.charCodeAt(ctx.p++)<<24)|(d.charCodeAt(ctx.p++)<<16)|(d.charCodeAt(ctx.p++)<<8)|(d.charCodeAt(ctx.p++)))>>>0;
             return val;
        },
       _readChunkType:function(ctx){
          var d = ctx.d;
          var str = d[ctx.p++]+d[ctx.p++]+d[ctx.p++]+d[ctx.p++];
          return str;
       },
        _makeReadOnly:function(b64data){
      slf._start("_makeReadOnly");
      // assume a valid png image encoded in base64;
      var bindata = slf._atob(b64data.replace(/\s+/g, '')); // remove white spaces that might have been inserted
      var pngctx={p:0,d:bindata};
      pngctx.p+=8;// skip pngheader
      // read IHDR
      var size = slf._readU32Int(pngctx);
      slf._readChunkType(pngctx); //IHDR
      pngctx.p+=size; //Data
      slf._readU32Int(pngctx);//CRC
      var metadataChunk = slf._prepareTextChunk(slf._LC_Scribble_MetaDataKey+String.fromCharCode(0)+"true");
      var newdata = pngctx.d.substring(0,pngctx.p)+metadataChunk+pngctx.d.substring(pngctx.p);
      var ret= slf._btoa(newdata);
      slf._end();
      return ret;
   },
   _atob:function(inp){
      if(window.atob){ return atob(inp); }
	  return Base64.decode(inp);
   },
   _btoa:function(inp){
      if(window.btoa){ return btoa(inp); }
	  return Base64.encode(inp);
   },
   _isReadOnly:function(b64data){
    slf._start("_isReadOnly");
       if(slf._isPng(b64data)){
           var testStr = slf._LC_Scribble_MetaDataKey+String.fromCharCode(0)+"true";
           var bindata = slf._atob(b64data.replace(/\s+/g, '')); // strip white spaces
           var pngctx={p:0,d:bindata};
           pngctx.p+=8;// skip header
           while(pngctx.p<pngctx.d.length){
               var size = slf._readU32Int(pngctx);
               var type = slf._readChunkType(pngctx);
               if(type=="tEXt"){
                   if(pngctx.d.indexOf(testStr,pngctx.p)==pngctx.p){
                       slf._end();
                       return true;
                   }
                  
              }
              pngctx.p+=size;
              slf._readU32Int(pngctx);// 
          }// while end
       }
       slf._end();
       return false;
   }
    };
    return slf;
})();

/**
 * JQuery widget definition starts here
 */
$.widget( "xfaWidget.ScribbleImageField", $.xfaWidget.imageField, {

    _widgetName:"ScribbleImageField",
    _geoLocQuery:null,
   _emptyImageVal:null,// should be null, but for now
   _extraInfo:null,
   _defaultStatus:"&nbsp;",
   _enforceGeoLoc:!!navigator.userAgent.match(/iPad/i),
   _sigCanvasWidth:696,
   _sigCanvasHeight:390,
   _geoCanvId:null,
    _geoLocAtBottom:false,
   _geoCanvasHeight:100,
   _geoCanvasWidth:696,
   
    _is_readonly:false,
	
    options: {
        tabIndex: 0,
        "role": "img"
    },

    getOptionsMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getOptionsMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "displayValue": function(val) {
                if(this.options.commitProperty) {
                    if(!val){
                        this._displayValue(this._extractData(this._createEmptyImageData()));
                        this.$userControl.addClass("emptyScribble");
                        this._is_readonly=false;
                    } else {
                        this.$userControl.removeClass("emptyScribble");
                        if(PNGUtil._isPng(val)){
                            var widgetValue = "data:image/png;base64,"+this.options.value;
                        }else {
                            var widgetValue = "data:;base64," + this.options.value;
                        }
                        this._setValue(widgetValue);
                    }
                }
            }
        })
    },

    getEventMap: function() {
        var parentOptionsMap = $.xfaWidget.defaultWidget.prototype.getEventMap.apply(this,arguments);
        return $.extend({},parentOptionsMap,{
            "scribblefocus":xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
            "click":null,
            "scribbleclick":xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT,
            "change":null,
            "scribblechange":xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
            "blur":null,
            "scribbleclose":xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT
        })
    },

	/**
	 * This function achieves following
	 * 1. Calculate dimensions of canvases to be used
	 * 2. Findout if right or bottom canvas is to be used for geo location
	 */

	 aspectRatioToBeUsed :function(){
        var aspectRatio ;
        if(this.options.aspectRatio && parseFloat(this.options.aspectRatio) > 0){
           aspectRatio = 1/parseFloat(this.options.aspectRatio);  //--in MF ratio is computed as height/width instead of width/height
        } else {
           var imgEl = this.element.children("img"),
               width = imgEl.attr('width'),
               height = imgEl.attr('height'),
               fieldWidth,
               fieldHeight;

           if(width){
              fieldWidth = parseInt(width,10);
           } else {
              fieldWidth = imgEl.width();
           }
           if(height){
              fieldHeight = parseInt(height,10);
           } else {
              fieldHeight = imgEl.height();
           }
           aspectRatio = fieldHeight/fieldWidth;
        }
	    return aspectRatio;
	 },

    _setUpCanvas:function(){
        var aspectRatio ;
		aspectRatio = this.aspectRatioToBeUsed();
       
        // max width, height of generated image
        var maxWidth = 640;
        var maxHeight = 480;
        
        // width of field scaled to fit max image size
        var scaledWidth;
        var scaledHeight;
        
        
		// approx pixels required for rendering geo loc info in 12pt Arial font 
		var approxGeoLocWidth=250;
		var approxGeoLocHeight=84;
        
        scaledWidth = maxWidth;
        scaledHeight = maxWidth*aspectRatio;
        if(scaledHeight>maxHeight){
            scaledHeight = maxHeight;
            scaledWidth = maxHeight/aspectRatio;
        }
        
        // set canvas dimensions
        if(aspectRatio>=1){
			this._geoCanvId='iEBox_geoCanvasBottom';
            this._geoLocAtBottom=true;
          
			
             this._geoCanvasWidth = scaledWidth;
			 // limit height to 30% of full height;
			 this._geoCanvasHeight=Math.min(approxGeoLocHeight,scaledHeight/3);
             this._sigCanvasWidth = scaledWidth;
             this._sigCanvasHeight= scaledHeight-(this._enforceGeoLoc?this._geoCanvasHeight:0);
        } else {
			this._geoCanvId='iEBox_geoCanvasRight';
            this._geoLocAtBottom=false;
           
			
            this._geoCanvasHeight = scaledHeight;
			// limit width to 30% of full width;
			this._geoCanvasWidth=Math.min(approxGeoLocWidth,scaledWidth/3);
            this._sigCanvasHeight= scaledHeight;
            this._sigCanvasWidth= scaledWidth-(this._enforceGeoLoc?this._geoCanvasWidth:0);
        }
       
    },

   render : function() {
       var geoLocMandatoryOnIpad = this.options.geoLocMandatoryOnIpad;
       if(typeof(geoLocMandatoryOnIpad)!="undefined"){
           this._enforceGeoLoc= this._enforceGeoLoc && (/^(true|1)$/i).test($.trim(geoLocMandatoryOnIpad));
       }
       this._wgtId="wid"+~~(Math.random()*2000)+"_"+new Date().getTime();

       var $control = $.xfaWidget.defaultWidget.prototype.render.apply(this, arguments)

       if(this.options.value || this.options.value != this._emptyImageVal){
          this._is_readonly=!!PNGUtil._isReadOnly(this.options.value);
       }
   
       if(this._is_readonly){
          $control.after("<div id='"+this._wgtId+"' class='sc_popUpMenu'></div>");
       } else {
          $control.after("<div id='"+this._wgtId+"' style='display:none;' class='sc_popUpMenu'></div>");
       }
	   
	   this._setUpCanvas();
       return $control;
    },

   click: function() {
        this.focus();
        var tmpEl = this.element.length?this.element[0]:this.element;
        if(this.options.access != "open")
          return;
       if (TouchUtil.POINTER_ENABLED || TouchUtil.TOUCH_ENABLED) {
           // simulate a click event
           tmpEl.dispatchEvent(TouchUtil.getPointerEvent(TouchUtil.POINTER_DOWN));
           tmpEl.dispatchEvent(TouchUtil.getPointerEvent(TouchUtil.POINTER_UP));
        }
        else {
              this.$userControl.triggerHandler("click");
        }
   },

    _attachEventHandlers:function($control){
	     if(TouchUtil.POINTER_ENABLED || TouchUtil.TOUCH_ENABLED){
            this._attachTouchEventHandlers($control);
         } else {
            this._attachMouseEventHandlers($control);
         }
         $control.keydown($.proxy(this._handleKeyDown,this));
    },
	_attachEventHandlerForCrossIcon:function($control){
	    var _that = this;
	    $control.mouseenter(function(event){
             if(_that.options.access != "open")
                    return;
             event.stopPropagation();
             if(_that._is_readonly){
                $('#'+_that._wgtId).css({display:'block'});
                var bodyMoveHandler;
                $('body').on('mousemove',bodyMoveHandler=function(event){
                    if(event.target!=$('#'+_that._wgtId)[0]&&event.target!=_that.$userControl[0]){
                        $('#'+_that._wgtId).css({display:'none'});
                         $('body').off('mousemove',bodyMoveHandler);
                    }
                });
              }
       });

       setTimeout(function(){ $("#"+_that._wgtId).click($.proxy(_that._onCrossClick,_that));},50);  
	},
    _attachTouchEventHandlers:function($control){
        var _timer,_that=this;
        var tmpEl = this.element.length?this.element[0]:this.element;
       tmpEl.addEventListener(TouchUtil.POINTER_DOWN,function(event){
           if(_that.options.access != "open")
              return;
             event.preventDefault();
           _timer = setTimeout(function(){
                _timer=0;
               _that._onCrossClick(event);
            },1000);
        });
       tmpEl.addEventListener(TouchUtil.POINTER_UP,function(event){
            if(_that.options.access != "open")
                return;
            event.preventDefault();
            if(_timer){
               clearTimeout(_timer);
               _that._onImageClick(event);
            } 
        });
		
	   if(TouchUtil.POINTER_ENABLED){
		     this._attachEventHandlerForCrossIcon($control);
			 setTimeout(function(){ $("#"+_that._wgtId).on(TouchUtil.POINTER_UP,function(event){
			        event.stopPropagation();
			 });},50);
	   }
    },

    _attachMouseEventHandlers:function($control){
         var _timer=0,_that=this,_hoverTimer=0;
        $control.dblclick(function(event){
            if(_that.options.access != "open")
                return;
           event.preventDefault();event.stopPropagation();
           if(_timer.val){
             clearTimeout(_timer);_timer =0;
           }
           _that._onCrossClick(event);
        }).click(function(event){
           _that.$userControl.trigger("scribbleclick",event);
           if(_that.options.access != "open")
                return;
           event.preventDefault();
           event.stopPropagation();
           if(_timer){
              clearTimeout(_timer);_timer=0;
            } else {
              _timer = setTimeout(function(){
                 _timer=0;
                 _that._onImageClick(event);
              },500);
            }
       });
	   
	   this._attachEventHandlerForCrossIcon($control);
       
    },

    _onCrossClick:function(event){
        if(!this._is_readonly) return;
        this.$userControl.trigger("scribblefocus",event);
        this.$userControl.trigger("scribbleclick",event);
        event.stopPropagation();
        $.alertBox.yesNo(null,
         this.localeStrings().clearSignatureConfirm,
         this.localeStrings().clearSignature,
         $.proxy(this._removeSigConfirmationHandler,this));
     },

     _removeSigConfirmationHandler:function(isYes){
        if(isYes){
           this._saveValue(this._emptyImageVal);
           this._displayValue(this._extractData(this._createEmptyImageData()));
           this.$userControl.addClass("emptyScribble").trigger("scribbleclose",{});
           this._is_readonly=false;
        }
     },

    _createEmptyImageData:function(){
         if(!this._emptyImageData){
            var emptyCanvasObj = document.createElement('canvas');
            emptyCanvasObj.style.width=this._sigCanvasWidth+'px';
            emptyCanvasObj.style.height=this._sigCanvasHeight+'px';
            emptyCanvasObj.width=this._sigCanvasWidth;
            emptyCanvasObj.height=this._sigCanvasHeight;
            var ctx = emptyCanvasObj.getContext('2d');
            ctx.fillStyle='#ffffff';
            ctx.clearRect(0,0,this._sigCanvasWidth,this._sigCanvasHeight);
            this._emptyImageData = emptyCanvasObj.toDataURL("image/png");
         }
         return this._emptyImageData;
     },

    getCommitValue: function() {
        return this.options.value
    },

    _saveValue:function(val){
        this.options.value=val;
        this.$userControl.trigger('scribblechange');
    },

    _displayValue:function(val){
        if(this.options.commitProperty) {
            //hardcode the widget VALUE by unknown image type
            if(val){
              var widgetValue = "data:image/png;base64,"+val;
                this._setValue(widgetValue);
            }
        }
        else
            this.logger().debug("xfaView","[DefaultWidget._update], User Control or Commit Property is null" );
    },

    _doOk:function(){
        var mainCanvas = document.createElement('CANVAS');
        var geoCnv = $('#'+this._geoCanvId)[0];
        var sigCnv = $('#iEBox_canvas')[0];
        var ctx = mainCanvas.getContext('2d');
       
        if(geoCnv.width>0&&geoCnv.height>0){
            
            if(this._geoLocAtBottom){
                mainCanvas.width=sigCnv.width;
                mainCanvas.height =sigCnv.height+geoCnv.height;
                ctx.drawImage(sigCnv,0,0);
                ctx.drawImage(geoCnv,0,sigCnv.height);
            } else {
                mainCanvas.width=sigCnv.width+geoCnv.width;
                mainCanvas.height =sigCnv.height;
                ctx.drawImage(sigCnv,0,0);
                ctx.drawImage(geoCnv,sigCnv.width,0);
            }
        } else {
             mainCanvas.width=sigCnv.width;
             mainCanvas.height =sigCnv.height;
             ctx.drawImage(sigCnv,0,0);
        }
        imageEditDialog.hide();
        var newdata = mainCanvas.toDataURL("image/png");//(this.myScribbleHandle||"").toString();
        
         var val,val1;
         if((val=/*=*/this._extractData(newdata))){
         //  val1 = PNGUtil._makeReadOnly(val);
            val = PNGUtil._makeReadOnly(val);
            this._saveValue(val);   
            this._is_readonly=true;       
          }
          this._geoLocQuery&&this._geoLocQuery.cancel();// cancel current geo loc request;
        this.$userControl.trigger("scribbleclose")
    },
    _handleOk:function(){
        if(this._enforceGeoLoc){
           this._geoLocQuery = new GeoLocQuery().init($.proxy(function(data){
               this._geoQuerySuccessHandler(data);
               this._doOk();
           },this),$.proxy(this._geoQueryErrorHandler,this));
           this._geoLocQuery.query();
           this._showMessage(this.localeStrings().fetchGeoLocation);
        } else {
          this._doOk();
        }
    },

    _handleCancel:function(){
         imageEditDialog.hide();
         this._geoLocQuery&&this._geoLocQuery.cancel();// cancel current geo loc request;
        this.$userControl.trigger("scribbleclose")
    },

    _handleClear:function(){
        this.myScribbleHandle.setEnabled(true);
        this._is_readonly=false;
        this._makeReadOnly(this._is_readonly);
        $('#iEBox_canvas')[0].width=this._sigCanvasWidth;
         $('#iEBox_caption').width(this._sigCanvasWidth);
		$('#iEBox_canvas')[0].height=this._sigCanvasHeight;
        $('#keyboard_Sign_Box')[0].value="";
        var geoCanv = $('#'+this._geoCanvId)[0];
        imageEditDialog.enableButtons({Ok:false,Clear:false});
        geoCanv.width=0;
        geoCanv.height=0;
        imageEditDialog._resize();
        this._geoLocQuery&&this._geoLocQuery.cancel();// cancel current geo loc request;
    },
    _makeReadOnly:function(readonly){
       imageEditDialog.enableButtons({Ok:false,Clear:false,Geo:!readonly,Brush:!readonly,Text:!readonly});
       if(readonly){
		   $('#iEBox_canvas').css({border:'1px solid gray'});
           $('#iEBox_caption').css({display:'none'});

       }
       this._defaultStatus = "&nbsp;";
       this._showMessage(this._defaultStatus);
    },

    _showMessage:function(msg){
        var _that = this;
        if(this._msgTimeout) { clearTimeout(this._msgTimeout); this._msgTimeout=0; }
         $("#iEBox_title").replaceWith('<div id="iEBox_title">'+msg+'</div>');
         this._msgTimeout = window.setTimeout(function(){
             $("#iEBox_title").replaceWith('<div id="iEBox_title">'+_that._defaultStatus+'</div>');
         },15000);
    },

    _geoQueryErrorHandler:function(err){
        this._showMessage(this.localeStrings().errorFetchGeoLocation);
    },

	_getLogMessage:function(key){
		     return this.logMsgs()[key]||key;
	},

    _handleGeo:function(){
          // initiate geolocation 
       if(navigator.geolocation){
           this._geoLocQuery = new GeoLocQuery().init($.proxy(this._geoQuerySuccessHandler,this),$.proxy(this._geoQueryErrorHandler,this));
           this._geoLocQuery.query();
           this._showMessage(this.localeStrings().fetchGeoLocation);
       } else {
           this.logger().debug("xfaView",this._getLogMessage("ALC-FRM-901-011"));
       }
    },

    // This Function is used to fetch the geolocation.
    calculateGeolocation: function(){
      this._handleGeo();
    },

    _handleText:function(){
        var signBoxEl=document.getElementById("keyboard_Sign_Box");
        var signCanvasEl=document.getElementById("iEBox_canvas");
        if(signBoxEl.value.length==0){
            this._handleClear();
        }
        this._disableSignatureCanvas();
        this._enableSignatureTextBox();
        signBoxEl.focus();
    },

    _disableSignatureTextBox:function(){
        document.getElementById("keyboard_Sign_Box").style.display = "none";
    },

    _enableSignatureTextBox:function(){
        document.getElementById("keyboard_Sign_Box").style.display = "inline-block";
    },

    _disableSignatureCanvas:function(){
        document.getElementById("iEBox_canvas").style.display = "none";
    },

    _enableSignatureCanvas:function(){
        document.getElementById("iEBox_canvas").style.display = "inline-block";
    },

    _handleBrushSelect:function(w){
        if(this.myScribbleHandle&&!this._is_readonly) {
            this.myScribbleHandle.setLineWidth(w);
        }
    },

    _handleBrush:function(evt){
        if($('#keyboard_Sign_Box')[0].value.length>0){
            this._handleClear();
        }
        this._disableSignatureTextBox();
        this._enableSignatureCanvas();
        imageEditDialog.toggleBrushList(evt);
    },
	_handleKeyDown:function(event){
		if(event.keyCode == ENTER_KEY || event.charCode == ENTER_KEY || event.which == ENTER_KEY) { // touch devices may return charCode
		    event.preventDefault();
		    this._onImageClick(event);
		} else if(event.keyCode == DELETE_KEY || event.charCode == DELETE_KEY || event.which == DELETE_KEY) {
		    this._onCrossClick(event);
		}
    },
    _dialogCallback:function(button_val,arg1){
           // add back on click handler
         //  this.$userControl.click($.proxy(this._onImageClick, this));
                     
           switch(button_val){
               case "Ok":
               this._handleOk();
               break;
               case "Cancel":
               this._handleCancel();
               break;
               case "Clear":
               this._handleClear();
               break;
               case "Geo":
               this.calculateGeolocation();
               break;
               case "BrushSelect":
               this._handleBrushSelect(arg1);
               break;
               case "Brush":
               this._handleBrush(arg1);
               break;
               case "Text":
               this._handleText();
               break;
              
           }
    },

    _geoQuerySuccessHandler:function(data){
        this._renderPosition(data);
    },

	_fitGeoLocText:function(latStr,longStr,timeStr,ctx,maxWidth,maxHeight){
	    var fontSize=12;
		ctx.font="bold "+fontSize+"pt Arial";
		var width = Math.max(ctx.measureText(latStr).width,ctx.measureText(longStr).width,ctx.measureText(timeStr).width);
		var lineHeight = ctx.measureText("m").width*1.5;
		while((width>maxWidth||3*lineHeight>maxHeight)&&fontSize>1){
		    fontSize--;
		    ctx.font="bold "+fontSize+"pt Arial";
		    width = Math.max(ctx.measureText(latStr).width,ctx.measureText(longStr).width,ctx.measureText(timeStr).width);
		    lineHeight = ctx.measureText("m").width*1.5;
		}
		return {width:width,lineHeight:lineHeight,fontSize:fontSize};
	},

    _renderPosition:function(position){
        if(position&&position.coords){
         this._showMessage("&nbsp;");
            var latStr = this.localeStrings().latitude+": " + position.coords.latitude;
            var longStr = this.localeStrings().longitude+": " + position.coords.longitude;
            var dateObj = new Date();
            var tZone = (dateObj.getTimezoneOffset()/60*-1);
            
            var timeStr = this.localeStrings().time+": "+(dateObj.getMonth()+1)+"/"+dateObj.getDate()+"/"+dateObj.getFullYear()+" "+dateObj.getHours()+":"+dateObj.getMinutes()+":"+dateObj.getSeconds()+((tZone>0)?" +":" ")+(tZone);
            var canvasObj  = $('#'+this._geoCanvId)[0];
			var sigCanvas = $('#iEBox_canvas')[0];
            var sigTextBox = $('#keyboard_Sign_Box')[0];
			var dummyCanvas = document.createElement('canvas');
            if(canvasObj){
			   var ctx = canvasObj.getContext('2d');
			   ctx.font="bold 12pt Arial";

			   canvasObj.width=this._geoCanvasWidth;
               canvasObj.height=this._geoCanvasHeight;
			   var layout = this._fitGeoLocText(latStr,longStr,timeStr,ctx,canvasObj.width,canvasObj.height);
               var aspectRatio ;
     		   aspectRatio = this.aspectRatioToBeUsed();
			   if(!this._enforceGeoLoc){
			       if(this._geoLocAtBottom){
                     dummyCanvas.height = this._sigCanvasHeight-canvasObj.height;
                     dummyCanvas.width = dummyCanvas.height/aspectRatio;
                   } else {
                     dummyCanvas.width = this._sigCanvasWidth-canvasObj.width;
					 dummyCanvas.height = dummyCanvas.width*aspectRatio;
				   }
				   // move drawn signature to a temporary canvas and scale it to new dimension
                   dummyCanvas.getContext('2d').drawImage(sigCanvas,0,0,dummyCanvas.width,dummyCanvas.height);
                   if(this._geoLocAtBottom){
                     sigCanvas.height = dummyCanvas.height;
                     sigTextBox.height = dummyCanvas.height;
                     sigCanvas.getContext('2d').drawImage(dummyCanvas,(sigCanvas.width-dummyCanvas.width)/2,0);
                   } else {
                     sigCanvas.width = dummyCanvas.width;
                     sigTextBox.width = dummyCanvas.width;
                     sigCanvas.getContext('2d').drawImage(dummyCanvas,0,(sigCanvas.height-dummyCanvas.height)/2);
                   }
                   $('#iEBox_caption').width(sigCanvas.width);
				   imageEditDialog.enableButtons({Clear:true});
			   }
			      
			   var fwidth = layout.width;
               var fheight = layout.lineHeight;
			   var bottomMargin=2;
               ctx.fillStyle='#555555';
               ctx.font="bold "+layout.fontSize+"pt Arial";
               ctx.fillText(latStr,0,canvasObj.height-2*fheight-bottomMargin);
               ctx.fillText(longStr,0,canvasObj.height-fheight-bottomMargin);
               ctx.fillText(timeStr,0,canvasObj.height-bottomMargin);
			   
			   imageEditDialog._resize();
            }
        }
    },
    _scribbleCallback:function(){
       imageEditDialog.enableButtons({Clear:true,Ok:true});  //  enable clear and ok buttons
    },
    _onImageClick:function(){
       if(!imageEditDialog.getIsOpen()){
           var _that = this;
           imageEditDialog.show("&nbsp;",$.proxy(this._dialogCallback, this));
           if(!this._enforceGeoLoc){
               $('#iEBox_Geo').css({display:'inline-block'});
           }
           var image = new Image();
           image.onload=function(){
               _that.myScribbleHandle = new Scribble("iEBox_canvas",image,image.width,image.height,$.proxy(_that._scribbleCallback,_that));
               _that.myScribbleHandle.setEnabled(!_that._is_readonly);
               $('#iEBox_caption').width(image.width);
               $('#iEBox_container').css({display:'table'});
               if($('#iEBox_container').length == 1){
                   $('#iEBox_container')[0].focus();
               }
               imageEditDialog._resize();
               imageEditDialog._reposition();      // recalculate position, so that the values are updated, esp. in iPad
           }
           if(!this.options.value||this.options.value==this._emptyImageVal){
               this._is_readonly=false;
               this.$userControl.addClass("emptyScribble");
               image.src = this._createEmptyImageData();
           } else {
               this.$userControl.removeClass("emptyScribble");
               if(PNGUtil._isPng(this.options.value)){
                   this._is_readonly = !!PNGUtil._isReadOnly(this.options.value);
			       image.src = "data:image/png;base64,"+this.options.value;//this.createBl _that.$userControl.attr(_that.options.commitProperty);
               } else {
                   image.src = "data:;base64," + this.options.value;//this.createBl _that.$userControl.attr(_that.options.commitProperty);
		       }
           }
           this._makeReadOnly(this._is_readonly);
       }
    },

    _extractData:function(datauri){
        var idx;
        if(datauri!=null&&datauri.length>0&&datauri.indexOf("data:")==0){
            if((idx=datauri.indexOf(","))>0){
                return datauri.substr(idx+1);
            }
        }
    },

    _setValue:function(val){
        this.$userControl.prop(this.options.commitProperty, val);
        this.$userControl.attr(this.options.commitProperty, val);
        if(this._dummyImg){
            this._dummyImg.setAttribute(this.options.commitProperty,val);
        }
    }
});
 //hack for IOS5 touch bug
  $(function(){
         $('body').on('touchstart', function(e) {});
  });
  
})($,xfalib);
(function ($, window, _) {

    var _defaults = {
        placeHolderText : "Enter comments here"
    };

    var AdobeFileAttachment = function (element, options) {
        this.options = options;
        this.$elementFileUploadBtn = [];
        this.$elementFileList = [];
        this.$element = $(element);
        if (this.$element.attr("multiple") && !xfalib.ut.Utilities._isDataContainerSupported()) {
            // remove multiple attribute if multi file selection in one go is not supported
            this.$element.removeAttr("multiple");
        }
        this.$parent = this.$element.parent();
        this.invalidFeature = {
            "SIZE":1,
            "NAME":2,
            "MIMETYPE":3
        };
        Object.freeze(this.invalidFeature);
        // initialize the regex initially
        this.regexMimeTypeList  = this.options.mimeType.map(function (value, i) {
            try {
                return new RegExp(value.trim());
            } catch (e) {
                // failure during regex parsing, don't return anything specific to this value since the value contains
                // incorrect regex string
                if(window.console) {
                    console.log(e);
                }
            }
        });
    };

    var isBrowserIE9OrIE10 = ($.browser.msie && ($.browser.version === '9.0' || $.browser.version === '10.0')),
        fileLabelsCount = 0;


    AdobeFileAttachment.prototype = {
        _fileIframeName : "guide-fu-iframe",
        _addFile : "Add File",

        clear: function () {
            this.$element.val('');
            this.$elementFileList.empty();
        },

        destroy: function () {
            this.$fileDomElements = $.map(this.$fileDomElements, function(item){
                // since item can be null or object, doing this check
                if(_.isObject(item) && item.val().length === 0) {
                    //TODO: remove item from dom, since there is a memory leak
                    return item;
                }
            });
            this.values = [];
            if(isBrowserIE9OrIE10){
                if(_.last(this.$fileDomElements) == null){
                    this.cloneFileInputAndUpdateIdForIE9();
                } else {
                    this.updateLabelForAttr(_.last(this.$fileDomElements).attr("id"));
                }
            }
            this.$element.trigger("change.fileupload");
        },

        _setUrl : function(url, index){
            this.$elementFileList.find("span.guide-fu-fileName").eq(index).data("key", url);
        },

        _getUrl : function(index) {
            return this.$elementFileList.find("span.guide-fu-fileName").eq(index).data("key");
        },
        getSetFilePathAndReturnNamePathMap: function(valueList) {

            var mapOfObjectsHavingTempPathAndFileNames = {},
                $temp,
                tempPath;

            $.each(this.$elementFileList.children(), function ( index, childLiElement) {
                $temp = $(childLiElement).find("span.guide-fu-fileName");
                tempPath = $temp.data("key");
                if(!tempPath && valueList && valueList[index]) {
                    $temp.data("key", valueList[index]);
                }
                mapOfObjectsHavingTempPathAndFileNames[$temp.html()] = tempPath || $temp.data("key");
            });
            return mapOfObjectsHavingTempPathAndFileNames;
        },


        value : function(value) {
            if(!_.isUndefined(value)) {
                var _self = this,
                    comments = this.comment(),
                    isChange = false,
                    fileNames = _.isArray(this.options.fileNames) ? this.options.fileNames : null,
                    oldUrls = {};
                // Cache the url before deletion
                this.$elementFileList.children().find("span.guide-fu-fileName").each(function(){
                    var url = $(this).data("key");
                    if(!_.isUndefined(url)){
                        var fileName = url.substring(url.lastIndexOf("/") + 1);
                        oldUrls[fileName] = url;
                    }
                });
                this.$elementFileList.empty();
                if(value != null) {
                    var arr = value.split("\n");
                    // contruct initial file name and value map
                    // this is done only once in entire live cycle, its done here, since we get value here
                    if (fileNames && _.isEmpty(this._initialFileValueFileNameMap)) {
                        for (var index = 0; index < fileNames.length; index++) {
                            _self._initialFileValueFileNameMap[arr[index]] = fileNames[index]
                        }
                    }
                    // Update the value array with the file
                    this.values = _.map(arr, function(fileName, index){
                        // Check if file Name is a path, if yes get the last part after "/"
                        var slash = fileName.lastIndexOf("/"),
                            fileUrl = fileName,
                            fileUploadUrl = null;
                        if(slash !== -1) {
                            // Store the cached url here
                            fileUrl = fileUploadUrl = fileName;
                            fileName = fileName.substring(slash + 1);
                            // case: when you click on save second time
                            if((_.isObject(_self.$fileDomElements[index]) && _self.$fileDomElements[index].val().length > 0) || _.isString(_self.$fileDomElements[index])){
                                isChange = true;
                                _self.$fileDomElements[index] = null;
                            } else if(_self.$fileDomElements[index] !== null) { // create a dummy file dom for the cached value
                                 isChange = true;
                                _self.$fileDomElements.splice(index, 0, null);
                            }
                        } else if (oldUrls[fileName]) {
                            fileUploadUrl = oldUrls[fileName];
                        }
                        // if fileNames options is explicitly passed, use it
                        if (fileNames && _self._initialFileValueFileNameMap[fileUrl]) {
                            fileName = _self._initialFileValueFileNameMap[fileUrl];
                        }
                        _self.showFileList(fileName, comments[index], fileUploadUrl);
                        return fileUrl;
                    });
                    if(isChange){
                        this.$element.trigger("change.fileupload");
                    }
                } else {
                    if(_.isArray(this.values) && this.values.length !== 0){
                        this.destroy();
                    }
                }
            }
            else {
                return this.values;
            }
        },

        fileAttachment: function(){
            return this.values;
        },

        comment : function(value){
            var _self = this,
                $elem = null,
                comments;
            if (!_.isUndefined(value)) {
                if(value != null) {
                    comments = value.split("\n");
                    $elem = this.$elementFileList.find('div.guide-fu-comment');
                    $elem.each(function(index){
                        $(this).text(comments[index]);
                    });
                }
            }
            else {
                $elem = this.$elementFileList.find('div.guide-fu-comment');
                comments = [];
                $elem.each(function(){
                    comments.push($(this).text());
                });
                return comments;
            }
        },

        multiSelect : function(value){
            if(value !== undefined)
                this.options.multiSelect = value;
            else
                return this.options.multiSelect;
        },

        fileSizeLimit : function(value){
            if(value !== undefined)
                this.options.fileSizeLimit = value;
            else
                return this.options.fileSizeLimit;
        },

        mimeType : function(value){
            if(value !== undefined)
                this.options.mimeType = value;
            else
                return this.options.mimeType;
        },

        access : function(value){
            if(value == "readOnly") {
                this.$element.attr("disabled", "disabled");
                //for readOnly hide the delete icon in file list
                $(this.$parent).addClass('guide-fu-disabled');
            }
            else if(value == "open") {
                this.$element.removeAttr("disabled");
                $(this.$parent).removeClass('guide-fu-disabled');
            }
        },

        fileList : function(value) {
            var filtered,
                _self = this;
            if(value !== undefined){
                this.$fileDomElements = [];
                _.each(value, function(item, index){
                    if((_.isObject(item) && (isBrowserIE9OrIE10 || item.val().length > 0)) || (_.isString(item))){
                         // check if index is within the length
                         // this is written for delete case
                         // if item is a string, then it should be set null
                         if(_.isString(item)){
                             item = null;
                         }
                         _self.$fileDomElements[index] = item;
                    }
                });
                filtered = this.$fileDomElements;
                // In case of IE9, get the last element of fileDom and update the id for label
                if(isBrowserIE9OrIE10 && value !== null){
                    // Case: if it is single select, and then we do a restore and then after attaching another file we click save
                    if(_.last(this.$fileDomElements) == null){
                        this.cloneFileInputAndUpdateIdForIE9();
                    } else {
                        this.updateLabelForAttr(_.last(this.$fileDomElements).attr("id"));
                    }
                }
            }
            else {
                // here filtered is a new array
                // A new array is returned over here so that the user of this API doesn't try to change the widget array directly
                filtered = $.map(this.$fileDomElements, function(item, index){
                    if(!item) {
                        return _self._getUrl(index);
                    } else if((item[0].files && item[0].files.length !== 0)
                            || (_self.options.multiSelect || item[0].value.length > 0)) {
                        return item;
                    }
                });
            }
            return filtered;
        },

        // file preview html
        fileItemPreview: function(){
            return $("<span></span>").addClass("guide-fu-filePreview glyphicon glyphicon-ok");
        },

        // force flag indicates that forcefully set the dom but don't update the options
        buttonText: function (value, force) {
            if (value !== undefined) {
                if(!force)
                    this.options.buttonText = value;
                this.$elementFileUploadBtn.find('span.guide-fu-label').html(value);
            } else {
                return this.options.buttonText;
            }
        },

        // To change the icon of the button, the user should customize the class
        btnIcon: function () {
            return $("<span></span>").addClass("guide-fu-icon glyphicon glyphicon-folder-open");
        },

        btnLabel: function(){
            return $("<span></span>").addClass("guide-fu-label").html(this.options.buttonText);
        },

        fileItemList: function(){
            return this.$parent.find(this.options.fileItemListClass);
        },

        getNewCommentElementSummary : function(text){
            return $("<div title='Click to edit' tabindex='0'></p>").addClass("guide-fu-comment").text(text || _defaults.placeHolderText);
        },

        getNewCommentElement : function(text){
            return $("<div contenteditable='true' tabindex='0'></div>").addClass("guide-fu-comment").text(text || "");
        },

        fileItem: function(fileName, comment, fileUrl){
            var $fileItem = $("<li></li>").addClass("guide-fu-fileItem");
            var nameWithoutMarker = xfalib.ut.Utilities._getNameWithoutMarker(fileName);
            var $elem = $("<span tabindex='0'></span>").addClass("guide-fu-fileName").attr("aria-label", nameWithoutMarker).text(nameWithoutMarker).appendTo($fileItem).keypress(function(e) {
                if (e.keyCode === 13 || e.charCode === 32) {
                    $(e.target).click();
                }
            }).click($.proxy(this.handleFilePreview, this));
            if(this.options.disablePreview) {
               $elem.addClass('non-preview-fileName');
            }
            if(fileUrl != null){
                $elem.attr("data-key", fileUrl);
            }
            $("<span tabindex='0'></span>").addClass("guide-fu-fileClose close").attr("role", "button").attr("aria-label", xfalib.locale.Strings.FileCloseAccessText + nameWithoutMarker).text("x").appendTo($fileItem).keypress(function(e) {
                if (e.keyCode === 13 || e.charCode === 32) {
                    $(e.target).click();
                }
            })
                .click($.proxy(this.handleClick, this));

            this.fileItemPreview().appendTo($fileItem);

            if(this.options.showComment){
                this.getNewCommentElementSummary(comment).appendTo($fileItem).focus($.proxy(this.handleCommentClick, this)).click($.proxy(this.handleCommentClick, this));
            }
            return $fileItem;
        },

        toggleFileUploadBtn: function(){
            if(this.options.multiSelect) {
                // Change the look of file upload button
                if(this.$elementFileList.children().length > 0){
                    // Change the text
                    this.buttonText(this._addFile, true);
                    // Change the icon too
                    this.$elementFileUploadBtn.find('span.guide-fu-icon').removeClass("glyphicon-folder-open").addClass("glyphicon-plus");
                } else {
                    this.buttonText(this.options.buttonText);
                    this.$elementFileUploadBtn.find('span.guide-fu-icon').removeClass("glyphicon-plus").addClass("glyphicon-folder-open");
                }
            }
        },

        showInvalidMessage: function(fileName, invalidFeature){
            var that = this;
            var IS_IPAD = navigator.userAgent.match(/iPad/i) !== null,
                IS_IPHONE = (navigator.userAgent.match(/iPhone/i) !== null);
            if(IS_IPAD || IS_IPHONE){
                setTimeout(function() {
                  that.invalidMessage(that,fileName, invalidFeature);
                }, 0);
            }
            else {
               this.invalidMessage(this,fileName, invalidFeature);
            }
        },

        invalidMessage: function(refObj,fileName, invalidFeature){
            if(invalidFeature === refObj.invalidFeature.SIZE) {
                alert(xfalib.ut.LocalizationUtil.prototype.getLocalizedMessage("", xfalib.locale.Strings["FileSizeGreater"], [fileName, refObj.options.fileSizeLimit]));
            } else if (invalidFeature === refObj.invalidFeature.NAME) {
                alert(xfalib.ut.LocalizationUtil.prototype.getLocalizedMessage("", xfalib.locale.Strings["FileNameInvalid"], [fileName]));
            } else if (invalidFeature === refObj.invalidFeature.MIMETYPE) {
                alert(xfalib.ut.LocalizationUtil.prototype.getLocalizedMessage("", xfalib.locale.Strings["FileMimeTypeInvalid"], [fileName]));
            }
        },

        /***
         * Finds the value in the array, if the value is a url then it uses the filename in the url to search for the text
         * This is done since our model stores the URL too in case of draft restore or clicking on save in guide
         * @param text          string representing the text of which the index is to be found
         * @param $elem         reference to the jquery element. This is used if there are duplicate file names present in the file upload.
         * @returns {number}
         * @private
         */
        _getIndexOfText : function(text, $elem){
            var index = -1,
                self = this,
                isDuplicatePresent = false;
            _.find(this.values, function(value, iter){
                // if value is a url, then compare with last
                var tempValue = value,
                    // can't use getOrElse here since value can have "." in URL and getOrElse splits based on period to find key inside object
                    fileName =  (_.isObject(self._initialFileValueFileNameMap) && typeof self._initialFileValueFileNameMap[value] !== undefined) ? self._initialFileValueFileNameMap[value] : null;
                if(tempValue.match(/\//g) && tempValue.match(/\//g).length > 1){
                    tempValue =  value.substring(value.lastIndexOf("/")+1);
                    tempValue = xfalib.ut.Utilities._getNameWithoutMarker(tempValue);
                }
                // we pass file name explicityly as options, if passed use that as fallback to find the URL
                if(tempValue === text || fileName === text){
                    index = iter;
                    isDuplicatePresent = self.values.indexOf(value, index + 1) !== -1;
                    if($elem && isDuplicatePresent){
                        // now check if duplicate present and get its correct index
                        // today all files are wrapped under .guide-fu-fileItem node
                        index = $elem.closest(".guide-fu-fileItem").index();
                    }
                    // check if there is a duplicate
                    // this is to just break the loop
                    return value;
                }
            });
            return index;
        },


        /*
         * Since input file element might contain multiple files.
         * This function takes absolute file index as parameter & returns position of the file w.r.t input file elt
         */
        _getFileObjIdx : function (index) {
            if (index >= 0) {
                var currentIdx = 0;
                for (var fileInputEltIdx = 0; fileInputEltIdx < this.$fileDomElements.length; fileInputEltIdx++) {
                    if (this.$fileDomElements[fileInputEltIdx]) {
                        var files = this.$fileDomElements[fileInputEltIdx][0].files;
                        if (files) {
                            var filesLength =  files.length;
                            if ( index <= currentIdx + filesLength - 1 ) {
                                return [fileInputEltIdx, index - currentIdx];
                            }
                            currentIdx+=files.length;
                        }
                    } else {
                        if (index == currentIdx) {
                            return [fileInputEltIdx,0];
                        }
                        currentIdx++;
                    }
                }
            }
            return null;
        },

        /*
         * This function returns FileList object of the passed file array
         */
        _getFileListItem : function (files) {
            try {
                var dataContainer = new DataTransfer() || (new ClipboardEvent("")).clipboardData;
                _.each(files, function (file) {
                    dataContainer.items.add(file);
                });
                return dataContainer.files;
            } catch(err) {
                console.error(err);
                throw err;
            }
        },

        _updateFilesInDom : function($fileDom, files) {
            // in safari, a change event is trigged if files property is changed dynamically
            // hence adding this check to clear existing state only for safari browsers
            this._isFileUpdate = true;
            $fileDom[0].files = this._getFileListItem(files);
            this._isFileUpdate = false;
        },

        /*
         * This function deletes files at specified indexes from input dom elt
         */
        _deleteFilesFromInputDom : function ($fileDomElt, deletedIndexes) {
            var remainingFiles = [];
            _.each($fileDomElt[0].files, function(file,idx){
                if(!deletedIndexes.includes(idx)){
                    remainingFiles.push(file);
                }
            });
            try {
                // in safari, a change event is trigged if files property is changed dynamically
                // hence adding this check to clear existing state only for safari browsers
                this._updateFilesInDom($fileDomElt, remainingFiles);
            } catch(err){
                console.error("Deleting files is not supported in your browser");
            }
        },

        /**
         * This event listener gets called on click of close button in file upload
         *
         * @param event
         */
        handleClick: function(event){

            var $elem = $(event.target),
                text = $elem.prev().text(),
                index = this._getIndexOfText(text, $elem),
                url = $elem.prev().data("key"),
                objectUrl = $elem.prev().data("objectUrl");
            if (index != -1) {
                this.values.splice(index, 1);
                var fileObjIdx = this._getFileObjIdx(index);
                var $fileDomElt = this.$fileDomElements[fileObjIdx[0]];
                if (!$fileDomElt || $fileDomElt[0].files.length === 1) {
                    this.$fileDomElements.splice(fileObjIdx[0], 1);
                } else {
                    this._deleteFilesFromInputDom($fileDomElt, [fileObjIdx[1]]);
                }
                if (isBrowserIE9OrIE10) {
                    this.cloneFileInputAndUpdateIdForIE9();
                }
                if (url != null) {
                    // remove the data so that others don't use this url
                    $elem.prev().removeData("key");
                }
                if(objectUrl) {
                    // revoke the object URL to avoid memory leaks in browser
                    // since file is anyways getting deleted, remove the object URL's too
                    window.URL.revokeObjectURL(objectUrl);
                }
            }
            // Remove the dom from view
            //All bound events and jQuery data associated with the element are also removed
            $elem.parent().remove();
            // trigger the change event to update the value
            this.$element.trigger("change.fileupload");
            // Set the focus on file upload button after click of close
            this.$elementFileUploadBtn.focus();

        },


        displaySVG: function (objectUrl) {
            const url = objectUrl;
            const img = window.document.createElement('img');
            img.src = url;
            const newTab = window.open('', '_blank', 'scrollbars=no,menubar=no,height=600,width=800,resizable=yes,toolbar=no,status=no');
            newTab.document.body.appendChild(img);
        },


        _previewFileUsingObjectUrl : function (file) {
            if (file) {
                if (window.navigator && window.navigator.msSaveOrOpenBlob) { // for IE
                    window.navigator.msSaveOrOpenBlob(file, file.name);
                } else {
                    var url = window.URL.createObjectURL(file);
                    if (file.type === 'image/svg+xml') {
                        this.displaySVG(url);
                    } else {
                        window.open(url, '', 'scrollbars=no,menubar=no,height=600,width=800,resizable=yes,toolbar=no,status=no');
                    }
                    return url;
                }
            }
        },

        // this function maintains a map for
        handleFilePreview: function(event){
            if(!this.options.disablePreview) {
                var $elem = $(event.target),
                    text = $elem.text(),
                    index = this._getIndexOfText(text, $elem),
                    fileDom = null,
                    fileName = null,
                    fileUrl = null,
                    timeStamp = new Date().getTime();

                // for draft usecase, if text contains "/" in it, it means the file is already uploaded
                // text should contain the path, assuming that the fileUrl is stored in data element

                if (index != -1) {
                    // Store the url of file as data
                    if(!_.isUndefined($elem.data("key")))
                        fileUrl = $elem.data("key");

                    if(fileUrl)  {
                        //prepend context path if not already appended
                        if (!(fileUrl.lastIndexOf(this.options._getUrl, 0) === 0)) {
                            fileUrl =  this.options._getUrl + fileUrl;
                        }
                        this.previewFile.apply(this, [null, {"fileUrl" : fileUrl}]);
                    } else {
                        var previewFileObjIdx = this._getFileObjIdx(index);
                        var previewFile = this.$fileDomElements[previewFileObjIdx[0]][0].files[previewFileObjIdx[1]];
                        var objectUrl = this._previewFileUsingObjectUrl(previewFile);
                        if (objectUrl) {
                            $elem.data("objectUrl", objectUrl);
                        }
                    }
                }
            }
        },

        previewFile: function(event){
            var url = null;
            if(_.isUndefined(arguments[1]))
                url = this.$element[this.options.uploaderPluginName]("getFileUrl");
            else
                url = arguments[1].fileUrl;
            var lastIndex = url.lastIndexOf('/');
            //to make sure url has a slash '/'
            if(lastIndex >= 0) {
                //encode the filename after last slash to ensure the handling of special characters
                url = url.substr(0, lastIndex) +'/'+ encodeURIComponent(url.substr(lastIndex + 1));
            }
            // this would work for dataURl or normal URL
            // todo: add support to preview base 64 encoded image, to preview base64 encoded binary, we would probably need
            // todo: the content type in the widget too
            window.open(url, '', 'scrollbars=no,menubar=no,height=600,width=800,resizable=yes,toolbar=no,status=no');

        },

        resetIfNotMultiSelect: function(){
            if(!this.options.multiSelect){
                // Reset the value and file array
                this.values = [];
                //this.comments = [];
            }
        },

        showFileList: function(fileName, comment, fileUrl){
            if(!this.options.multiSelect || fileName == null || _.isUndefined(fileName)) {
                // if not multiselect, remove all the children of file list
                this.$elementFileList.empty();
            }

            // Add the file item
            // On click of close, remove the element and update the model
            // handle on click of preview button
            if(fileName != null) {
                this.$fileItem = this.$elementFileList.append(this.fileItem(fileName, comment, fileUrl));
            }
        },

        /**
         * Handles the click on comment field
         *
         * TODO: Implement show/hide behaviour instead of replaceWith
         * This may be cause problem during bubble up of event
         *
         * @param event
         */
        handleCommentClick : function(event){
            var $commentElem = null,
                $elem = $(event.target);
            if ($elem.text() === _defaults.placeHolderText) {
                $commentElem = this.getNewCommentElement()
            } else {
                $commentElem = this.getNewCommentElement($(event.target).text());
            }
            $elem.replaceWith($commentElem);
            // register the event again
            if(isBrowserIE9OrIE10){
                $commentElem.focus().focusout($.proxy(this.handleCommentBlur, this));
            } else {
                $commentElem.focus().blur($.proxy(this.handleCommentBlur, this));
            }
        },

        handleCommentBlur : function(event){
            var $commentSummaryElem = null,
                $elem = $(event.target);
            if ($elem.text() === _defaults.placeHolderText) {
                $commentSummaryElem = this.getNewCommentElementSummary();
            } else {
                $commentSummaryElem = this.getNewCommentElementSummary($(event.target).text());
            }
            $elem.replaceWith($commentSummaryElem);
            $commentSummaryElem.focus($.proxy(this.handleCommentClick,this)).click($.proxy(this.handleCommentClick,this));
            // Add a div with the html
            this.$element.trigger("change.fileupload");
        },

        // checks if file name is valid or not to prevent security threats
        isValid : function(fname) {
            var rg1=/^[^\\/:\*\;\$\%\?"<>\|]+$/; // forbidden characters \ / : * ? " < > | ; % $
            var rg2=/^\./; // cannot start with dot (.)
            var rg3=/^(nul|prn|con|lpt[0-9]|com[0-9])(\.|$)/i; // forbidden file names
            return rg1.test(fname) && !rg2.test(fname) && !rg3.test(fname);
        },

        handleChange: function (evnt) {
            if (!this._isFileUpdate) {
                var currFileName = '',
                    inValidSizefileNames = '',
                    inValidNamefileNames = '',
                    inValidMimeTypefileNames = '',
                    $elem = $(evnt.target),
                    files = $elem[0].files;
                // Initially set the invalid flag to false
                // if not multiselect then remove the extra domELement clone
                if (!this.options.multiSelect && this.$fileDomElements.length > 1) {
                    this.$fileDomElements.splice(0, 1)
                }

                var isInvalidSize = false,
                    isInvalidFileName = false,
                    isInvalidMimeType = false;
                this.resetIfNotMultiSelect();
                // Iterate through all the files
                if (isBrowserIE9OrIE10) { // IE9 doesn't support FileList, hence files variable is undefined
                    currFileName = $elem.val().split("\\").pop();
                    //update the last element of array
                    if (this.$fileDomElements.length > 0) {
                        this.$fileDomElements[this.$fileDomElements.length - 1] = $elem;
                    }
                    this.cloneFileInputAndUpdateIdForIE9();

                    // In case of IE9, only do this
                    if (_.isUndefined(files)) {
                        this.showFileList(currFileName);
                        this.values.push(currFileName);
                        // trigger the change event to update the value
                        this.$element.trigger("change.fileupload");
                    }
                }
                if (!_.isUndefined(files)) {
                    var invalidFilesIndexes = [];
                    _.each(files, function (file, fileIndex) {
                        var isCurrentInvalidFileSize = false,
                            isCurrentInvalidFileName = false,
                            isCurrentInvalidMimeType = false;
                        currFileName = file.name.split("\\").pop();
                        // Now size is in MB
                        var size = file.size / 1024 / 1024;
                        // check if file size limit is within limits
                        if ((size > parseFloat(this.options.fileSizeLimit))) {
                            isInvalidSize = isCurrentInvalidFileSize = true;
                            inValidSizefileNames = currFileName + "," + inValidSizefileNames;
                        } else if (!this.isValid(currFileName)) {
                            // check if file names are valid (ie) there are no control characters in file names
                            isInvalidFileName = isCurrentInvalidFileName = true;
                            inValidNamefileNames = currFileName + "," + inValidNamefileNames;
                        } else if (file.type) {
                            var isMatch = this.regexMimeTypeList.some(function (rx) {
                                return rx.test(file.type);
                            });
                            if (!isMatch) {
                                isInvalidMimeType = isCurrentInvalidMimeType = true;
                                inValidMimeTypefileNames = currFileName + "," + inValidMimeTypefileNames;
                            }
                        }

                        // if the file is not invalid, show it and push it to internal array
                        if (!isCurrentInvalidFileSize && !isCurrentInvalidFileName && !isCurrentInvalidMimeType) {
                            this.showFileList(currFileName);
                            this.values.push(currFileName);
                        } else {
                            invalidFilesIndexes.push(fileIndex);
                        }


                    }, this);

                    if (invalidFilesIndexes.length > 0) {
                        var currentFileDomIndex,
                            $currentFileDomElement,
                            filesCount;
                        if (this.$fileDomElements.length > 0) {
                            currentFileDomIndex = this.$fileDomElements.length - 1;
                            $currentFileDomElement = this.$fileDomElements[currentFileDomIndex];
                            if ($currentFileDomElement && $currentFileDomElement.length > 0) {
                                filesCount = $currentFileDomElement[0].files.length;
                                //if all the files are invalid remove the input element as well otherwise only remove the invalid files.
                                if (filesCount === invalidFilesIndexes.length) {
                                    this.$fileDomElements.splice(-1, 1);
                                } else {
                                    this._deleteFilesFromInputDom($currentFileDomElement, invalidFilesIndexes);
                                }
                            }
                        }

                        // in case of IE10, create one extra element
                        if (isBrowserIE9OrIE10) {
                            this.cloneFileInputAndUpdateIdForIE9();
                        }
                    }

                    // trigger the change event to update the value
                    this.$element.trigger("change.fileupload");
                }

                if (isInvalidSize) {
                    this.showInvalidMessage(inValidSizefileNames.substring(0, inValidSizefileNames.lastIndexOf(',')), this.invalidFeature.SIZE);
                } else if (isInvalidFileName) {
                    this.showInvalidMessage(inValidNamefileNames.substring(0, inValidNamefileNames.lastIndexOf(',')), this.invalidFeature.NAME);
                } else if (isInvalidMimeType) {
                    this.showInvalidMessage(inValidMimeTypefileNames.substring(0, inValidMimeTypefileNames.lastIndexOf(',')), this.invalidFeature.MIMETYPE);
                }
            }
        },

        cloneFileInputAndUpdateIdForIE9 : function(){
            var elem = _.last(this.$fileDomElements),
                elemExists = elem != null,
                elemHasValue = elemExists && elem.val().length > 0,
                elemId = null,
                selector = null;

            // CQ-4237903 : create clone to handle the case when user clicks cancel in chrome and for multiselect
            // on clicking cancel in chrome file browser, chrome removes all the files from the input element
            // remove the extra clone in $fileDomElement on handleChange
            if(!elemExists || elemHasValue) {
                elem = this.$element.clone();
                // copy the data attributes
                elem.data(this.$element.data());
                if(isBrowserIE9OrIE10){
                    elemId = this.$element.attr("id") + (++fileLabelsCount);
                    elem.attr("id", elemId);
                    elem.css({
                        'position' : 'absolute',
                        'top' : '-2000px',
                        'left': '-2000px'
                    });
                    elem.appendTo('body');
                    this.updateLabelForAttr(elemId);
                }
                elem.change($.proxy(this.handleChange, this));
                this.$fileDomElements.push(elem);
            }
            // Case: if it is not multiselect and if the first file dom element is null
            // this case would hit when we restore a single select file attachment and attach a new file
            if(!this.options.multiSelect && this.$fileDomElements[0] === null){
                //Splice null out of it, since we are attaching a new file
                this.$fileDomElements.splice(0, 1);
            }
            // if the browser is not IE9, then click it
            if(!isBrowserIE9OrIE10) {
                elem.click();
            }
            return true;
        },

        /**
         * In case of IE9, get the last element of fileDom and update the id for label
         *
         * @param fileInputId
         */
        updateLabelForAttr : function(fileInputId){
            this.$label.attr("for" , fileInputId);
        },

        createLabelForFileInput : function (fileInputId){
            if(isBrowserIE9OrIE10) {
                this.$label = $("<label></label>").addClass("guide-fu-attach-button button")
                        .text(this.options.buttonText)
                        .attr('for',fileInputId);
                this.$elementFileUploadBtn.replaceWith(this.$label);
                this.$label.parent().attr("tabindex", 0).attr("role", "button").attr("aria-label", this.options.screenReaderText || "");
            }
        },


        constructor: function () {
            // Initialize the self instance
            var _self = this,
                isFirst = true;
            //jquery instance of file upload button
            this.$elementFileUploadBtn = this.$parent.find(this.options.buttonClass);
            this.$elementFileUploadBtn.attr("aria-label", this.options.screenReaderText || "");
            if(isBrowserIE9OrIE10){
                this.elementId = this.$element.attr("id");
                this.createLabelForFileInput(this.$element.attr("id"));
            }

            // html for file list
            this.$elementFileList = $(this.fileItemList());
            // Initialize the value and file(Refer FileList class mdn)
            this.values = [];
            this._initialFileValueFileNameMap = {};
            // List of dom elements of input type file
            this.$fileDomElements = [];

            var flag = false,
                $currElem = null;

            $(document).mousedown(function(e) {
                $currElem = $(e.target);
            });
            // Enter key should result in click of button
            this.$elementFileUploadBtn
                .focus(function(){
                    _self.$element.trigger("focus.fileupload");
                })
                .click($.proxy(this.cloneFileInputAndUpdateIdForIE9, this))
                .blur(function(event){
                    // Check if the currElem does not belong to the fileItemList
                    if(!flag && $currElem!= null && $currElem.closest(".guide-fu-fileItemList").length <=0){
                        _self.$element.trigger("focusout.fileupload");
                    }
                    flag = false;
                });
            //Initialize the filePreview Plugin
            this.$element[this.options.uploaderPluginName]({
                iframeContainer: this.options.iframeContainer,
                _filePath: this.options._filePath,
                _uuidGenerator: this.options._uuidGenerator,
                _getUrl: this.options._getUrl

            });
            // Getting input file value
            // listening on fileuploaded event
            this.$element.change($.proxy(this.handleChange, this))
                .on("adobeFileUploader.fileUploaded", $.proxy(this.previewFile, this));
        }
    };

    $.fn.adobeFileAttachment = function (option, value) {
        var get = '',
            element = this.each(function () {
                // in case of input type file
                if ($(this).attr('type') === 'file') {
                    var $this = $(this),
                        data = $this.data('adobeFileAttachment'),
                        options = $.extend({}, AdobeFileAttachment.prototype.defaults, typeof option === 'object' && option);

                    // Save the adobeFileAttachment data in jquery
                    if (!data) {
                        $this.data('adobeFileAttachment', (data = new AdobeFileAttachment(this, options)));
                        data.constructor();
                    }

                    // code to get and set an option
                    if (typeof option === 'string') {
                        get = data[option](value);
                    }
                }
            });

        if (typeof get !== 'undefined') {
            return get;
        } else {
            return element;
        }
    };

    // fileSizeLimit is in MB, default value is 2MB
    AdobeFileAttachment.prototype.defaults = {
        'buttonText': 'Attach',
        'multiSelect': false,
        'fileSizeLimit': 2,
        'uploaderPluginName': "adobeFileUploader",
        'mimeType' : ['audio/*', 'video/*', 'image/*', 'text/*', 'application/pdf']
    };

})($, window, window._);
(function($, _) {
    var xfaUtil = xfalib.ut.XfaUtil.prototype;
    $.widget( "xfaWidget.fileUpload", $.xfaWidget.abstractWidget, {

        _widgetName:"fileUpload",
        _superPrototype : $.xfaWidget.abstractWidget.prototype,
        getOptionsMap: function(){
            var parentOptionsMap = this._superPrototype.getOptionsMap.apply(this,arguments),
                newMap = $.extend({},parentOptionsMap, $.extend({}, this.options, {
                    "value" : function(value) {
                        this.$userControl.adobeFileAttachment("value", value);
                    },
                    "fileList": function(value){
                        this.$userControl.adobeFileAttachment("fileList", value);
                    },
                    "comment" : function(value){
                        this.$userControl.adobeFileAttachment("comment", value);
                    },
                    // "access" can be either open or readonly
                    "access" : function(value){
                        this.$userControl.adobeFileAttachment("access", value);
                    }

                }));

            return newMap;

        },
        // TODO: Will need to remove this functions
        //  will be tracked by LC-391200

        _initializeOptions: function () {
            _.each(this.optionsHandler, function (value, key) {
                // overriding the behaviour of _initializeOptions
                // only for _uuidGenerator
                // as we font want getUUID to be called at render time
                if (typeof value === "function" && key !== '_uuidGenerator' ) {
                        value.apply(this, [this.options[key]])
                }
            }, this)
        },

        _getFileList: function(){
            return this.$userControl.adobeFileAttachment("fileList");
        },

        _getComment: function(){
            return this.$userControl.adobeFileAttachment("comment");
        },
        _getFileNamePathMap: function (pathList) {
            return this.$userControl.adobeFileAttachment("getSetFilePathAndReturnNamePathMap", pathList);
        },
        getEventMap: function() {
            var parentEventMap = this._superPrototype.getEventMap.apply(this, arguments),
                newMap = $.extend({}, parentEventMap,
                    {
                        "change" : null,
                        "focusout.fileupload" : xfaUtil.XFA_EXIT_EVENT,
                        "focus.fileupload" : xfaUtil.XFA_ENTER_EVENT,
                        "change.fileupload" : xfaUtil.XFA_CHANGE_EVENT
                    });
            return newMap;
        },
        render: function() {
            var $el = this._superPrototype.render.apply(this,arguments);
            $el.adobeFileAttachment(this.getOptionsMap());
            return $el;
        },
        showDisplayValue: function() {
             //since value can't be set in file element input, leaving this fn empty
        },
        showValue: function() {
            //since value can't be set in file element input, leaving this fn empty
        },
        getCommitValue: function() {
            this.options.fileList = this._getFileList();
            this.options.comment = this._getComment();
            return this.$userControl.adobeFileAttachment("value");
        }
    });
})($, window._);

/**
 * Adobe FilePreview Widget Plugin
 *
 * Options expected by file preview is the url
 *
 * Options Required Are:
 *
 *  iframeName: Name of the Iframe
 *  iframeContainer: Container of the iframe(eg Body)
 *  fileUploadPath: Path where the file is to be uploaded
 *  fileUploadServlet: Servlet where the file is to be uploaded
 *
 */
(function ($, _) {

    var AdobeFileUploader = function (element, options) {
        this.options = options;
        this.$element = $(element);
    };

    AdobeFileUploader.prototype = {

        _fileIframeName: "guide-fu-iframe",

        _filePath: "/tmp/fd/mf",

        _iframeContainer: "body#formBody",


        fileIframe: function (name) {
            return $("<iframe></iframe>").attr({
                style: "display:none",
                name: name
            });
        },

        uploadFile: function (fileObject) {
            var multiple = false,
                fileName = null,
                actionUrl = null,
                fileUploadPath = fileObject.fileUploadPath,
                uuid;

            if (!fileUploadPath) {
                uuid = fileObject._uuidGenerator();
            }

            // if uuid exists only then upload the file in the current  instance
            if (_.isObject(fileObject) && (fileUploadPath || uuid)) {
                var fileDom = fileObject.fileDom,
                    $form = $(this.options.iframeContainer).find(".filePreview");
                fileName = fileObject.fileName;
                multiple = fileObject.multiple;
                if(!fileUploadPath) {
                    fileUploadPath = this.options.fileUploadPath + "/" + uuid;
                }
                if (fileDom !== null) {
                    //prepend contextpath
                    actionUrl = fileObject._getUrl + fileUploadPath;
                    if (!multiple) {
                        if (!(fileUploadPath.lastIndexOf(fileObject._getUrl, 0) === 0)) {
                            this.fileUrl = fileObject._getUrl + fileUploadPath + "/" + fileName;
                        } else {
                            this.fileUrl = fileUploadPath + "/" + fileName;
                        }
                    } else {
                        this.fileUrl = actionUrl;
                    }
                    // done to solve issue LC-5835
                    if($form.length === 0) {
                        $form = $("<form method='post' enctype='multipart/form-data'/>")
                            .addClass("filePreview")
                            // create id so that it does not intercept with other forms in the page
                            .attr({
                                id : "form" + new Date().valueOf(),
                                action : actionUrl,
                                target : this.options.iframeName
                            })
                            .appendTo(this.options.iframeContainer);
                    } else {
                        /// first empty all children, using detach so that data is not clear
                        $form.children().detach();
                        // now update the new attributes
                        $form.attr({
                            action : actionUrl,
                            target : this.options.iframeName
                        });
                    }
                    // this is done so that the other events attached at some other level in DOM Tree don't interfere
                    $form.one("submit", function(evnt){
                        evnt.stopPropagation();
                    });

                     var data = new FormData();

                    if (multiple) {
                        _.each(fileDom, function (fileDomElement, index) {
                            // OOTB, this code is still used in dashboard
                            if(fileDomElement !== null && !_.isString(fileDomElement)) {
                                $(fileDomElement[0]).attr('name', fileName[index]).appendTo($form);
                                // fileDomElement might contain multiple files so all the files needs to be added to formdata.
                                var currentFileNames = fileName[index].split("\n");
                                for(var fileIndex = 0; fileIndex < currentFileNames.length; fileIndex++) {
                                    data.append(currentFileNames[fileIndex], fileDomElement[0].files[fileIndex]);
                                }
                            }
                        }, this);
                    } else {
                        fileDom.attr('name', fileName).appendTo($form);
                        data.append(fileName, fileDom[0].files[0]);
                    }

                    /* UseCase: Suppose the fileName is in other language, on click of fileName, it tries to upload the file
                     so that it could be preview, this change would ensure that the file is properly previewed supporting
                     the given UTF-8 charset */
                    $("<input type='hidden' name='_charset_' value='UTF-8'/>").appendTo($form);
                    data.append("_charset_", "UTF-8");
                    if (!multiple) {
                        this.fileMap[this.fileUrl] = this.$element;
                    }
                    var self = this;
                    $.ajax({
                        url: $form.attr("action"),
                        data: data,
                        cache: false,
                        contentType: false,
                        processData: false,
                        method: 'POST',
                        type: 'POST',
                        success: function(data){
                            if (!multiple) {
                                self.handleSingleFileUpload(data);
                            } else {
                                self.handleMultipleFileUpload(data);
                            }
                        },
                        error: function() {
                            this.$element.trigger("adobeFileUploader.fileUploadFailed");
                        }
                    });
                }
            }
            return this.fileUrl;
        },

        handleMultipleFileUpload: function (data) {
            this.$element.trigger("adobeFileUploader.multipleFileUploaded");
        },

        getFileUrl: function () {
            return this.fileUrl;
        },

        getUrlContentsFromUploadData: function (data) {
            var temp;
            if(data != null) {
                temp = $(data).find("#ChangeLog").text().split("br", 2)[1];
            } else {
                var selector = this.options.iframeContainer + " iframe[name='" + this.options.iframeName + "']";
                temp = $(selector).contents().find("#ChangeLog").text().split("br", 2)[1];
            }
            
            temp = temp.substring(temp.indexOf("created") + 9, temp.indexOf(";<"));
            temp = temp.substring(0, temp.length - 2);
            var index = temp.indexOf("/jcr:content");
            if (index !== -1)
                temp = temp.substring(0, index);
            return temp;
        },

        handleSingleFileUpload: function (data) {
            var url = this.getUrlContentsFromUploadData(data);

            //prepend context path
            url = this.options._getUrl + url;
            if (url in this.fileMap) {
                this.fileMap[url].trigger("adobeFileUploader.fileUploaded");
            }
        },

        initialize: function () {
            // Put iframe inside the iframe container
            // On the load of iframe, display the contents of file
            // since there is only one iframe for all the file attachments, there may be race condition
            if (this.$iframe == null || this.$iframe.length === 0) {
                this.$iframe = this.fileIframe(this.options.iframeName).appendTo(this.options.iframeContainer);
                // since there is only iframe for the preview of all file attachments
                // this map is added in the closure scope
                // map contains the url(key) vs fileDomElement(value)
                // it helps avoids the race condition
                this.fileMap = {};
            }
        }
    };

    $.fn.adobeFileUploader = function (option, value) {
        var get = '',
            element = this.each(function () {
                // in case of input type file
                if ($(this).attr('type') === 'file') {
                    var $this = $(this),
                        data = $this.data('adobeFileUploader'),
                        options = $.extend({}, AdobeFileUploader.prototype.defaults(option, value), typeof option === 'object' && option);

                    // Save the adobeFileAttachment data in jquery
                    if (!data) {
                        $this.data('adobeFileUploader', (data = new AdobeFileUploader(this, options)));
                        data.initialize();
                    } else {
                        // update elements if not equal, since sometimes one can clone too
                        if(data.$element.get(0) !== this) {
                            data.$element = $(this);
                        }
                    }

                    // code to get and set an option
                    if (typeof option === 'string') {
                        get = data[option](value);
                    }
                }
            });

        if (typeof get !== 'undefined') {
            return get;
        } else {
            return element;
        }
    };


    AdobeFileUploader.prototype.defaults = function (options,value)  {
        var propertyObject = {};
        if(typeof options == 'object') {
            propertyObject._fileIframeName = options._fileIframeName;
            propertyObject._filePath = options._filePath;
            propertyObject.actionUrl = options.actionUrl;
            propertyObject._getUrl = options._getUrl;
        }
        if(typeof  value == 'object') {
            propertyObject._fileIframeName = value._fileIframeName;
            propertyObject._filePath = value._filePath;
            propertyObject.actionUrl = value.actionUrl;
            propertyObject._getUrl = options._getUrl;
        }
        return {
            'fileUploadPath': propertyObject._filePath || AdobeFileUploader.prototype._filePath,
            'iframeName': AdobeFileUploader.prototype._fileIframeName + new Date().valueOf(),
            'fileUploadServlet': propertyObject._filePath || AdobeFileUploader.prototype._filePath,
            'iframeContainer': propertyObject._iframeContainer || AdobeFileUploader.prototype._iframeContainer,
            '_getUrl': propertyObject._getUrl || ""
        };
    };

})($, window._);

/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function(_,xfalib) {
    var Constants = {
        accessValues : ["open","protected","readOnly","nonInteractive"],
        presenceValues : ["visible", "hidden","inactive","invisible"],
        itemSaveValues : [0,1],
        valueOverrideValues : [0,1],
        oneOfChild : {type: "oneOfChild", min:0, max:1},
        zeroOrMore : {type: "zeroOrMore",min:0, max:Infinity},
        zeroOrOne : {type: "zeroOrOne",min:0, max:1},
        zeroOrTwo : {type: "zeroOrTwo", min:0, max:2},
        zeroOrFour : {type: "zeroOrFour", min:0, max:4},
        oneOrMore : {type: "oneOrMore", min:1, max:Infinity},

        encryptDataOperationValues : ["encrypt", "decrypt"],
        requiredTypeValues : ["optional", "required"],
        dataValues : ["link", "embed"],
        hScrollPolicyValues : ["auto", "off", "on"],
        disableAllValues : ["0", "1"],
        formatTestValues : ["warning", "disabled", "error"],
        nullTestValues : ["disabled", "error", "warning" ],
        scriptTestValues : ["error", "disabled", "warning"],
        afterValues : ["auto", "contentArea", "pageArea", "pageEven", "pageOdd"],
        beforeValues : ["auto", "contentArea", "pageArea", "pageEven", "pageOdd"],
        startNewValues : ["0", "1"],
        circularValues : ["0", "1"],
        handValues : ["even", "left", "right"],
        highlightValues : ["inverted", "none", "outline", "push"],
        activityValues : ["click", "change", "docClose", "docReady", "enter",
            "exit", "full", "indexChange", "initialize",
            "mouseDown", "mouseEnter", "mouseExit", "mouseUp",
            "postExecute", "postOpen", "postPrint", "postSave",
            "postSign", "postSubmit", "preExecute", "preOpen",
            "prePrint", "preSave", "preSign", "preSubmit",
            "ready", "validationState"],
        listenValues : ["refOnly", "refAndDescendents"],
        breakValues : ["close", "open"],
        targetTypeValues : ["auto", "contentArea", "pageArea", "pageEven", "pageOdd"],
        signTypeValues : ["PDF1.3", "PDF1.6"],
        signDataOperationValues : ["sign", "clear", "verify"],
        aspectValues : ["fit", "actual", "height", "none", "width"],
        transferEncodingValues : ["none", "package", "base64"],
        manifestActionValues : ["include", "all", "exclude"],
        traverseDelegateValues : ["0", "1"],
        traverseOperationValues : ["next", "back", "down", "first", "left", "right", "up"],
        slopeValues : ["\\", "/"],
        excludeAllCapsValues : ["0", "1"],
        excludeInitialCapValues : ["0", "1"],
        hyphenateValues : ["0", "1"],
        allowNeutralValues : ["0", "1"],
        markValues : ["default", "check", "circle", "cross", "diamond", "square", "star"],
        shapeValues : ["square", "round"],
        commitOnValues : [ "select", "exit"],
        openValues : ["userControl", "always", "multiSelect", "onEntry" ],
        textEntryValues : ["0", "1"],
        linearTypeValues : ["toRight", "toBottom", "toLeft", "toTop"],
        edgeCapValues : ["square", "butt", "round"],
        strokeValues : ["solid", "dashDot", "dashDotDot", "dashed", "dotted", "embossed", "etched", "lowered", "raised"],
        cornerInvertedValues : ["0", "1"],
        cornerJoinValues : ["square","round"],
        speakDisableValues : ["0", "1"],
        speakPriorityValues : [ "custom", "caption", "name", "toolTip"],
        captionPlacementValues : ["left", "bottom", "inline", "right", "top"],
        orientationValues : ["portrait", "landscape"],
        mediumTrayInValues : ["auto", "delegate", "pageFront"],
        mediumTrayOutValues : ["auto", "delegate"],
        patternTypeValues : ["crossHatch", "crossDiagonal", "diagonalLeft", "diagonalRight", "horizontal", "vertical"],
        keepIntactValues : ["none", "contentArea", "pageArea"],
        keepNextValues : ["none", "contentArea", "pageArea"],
        keepPreviousValues : ["none", "contentArea", "pageArea"],
        passThroughValues : ["0", "1"],
        allowRichTextValues : ["0", "1"],
        multiLineValues : ["1", "0"],
        vScrollPolicyValues : ["auto", "off", "on"],
        kerningModeValues : ["none", "pair"],
        lineThroughValues : ["0", "1", "2"],
        lineThroughPeriodValues : ["all", "word"],
        fontOverlineValues : ["0", "1", "2"],
        fontOverlinePeriodValues : ["all", "word"],
        postureValues : ["normal", "italic"],
        underlineValues : ["0", "1", "2"],
        underlinePeriodValues : ["all", "word"],
        fontWeightValues : ["normal", "bold"],
        checksumValues : ["none", "1mod10", "1mod10_1mod11", "2mod10", "auto"],
        dataPrepValues : ["none", "flateCompress"],
        printCheckDigitValues : ["0", "1"],
        textLocationValues : ["below", "belowEmbedded", "none", "above", "aboveEmbedded"],
        truncateValues : ["0", "1"],
        upsModeValues : ["usCarrier", "internationalCarrier", "secureSymbol", "standardSymbol"],
        mdpPermissionsValues : ["2", "1", "3"],
        mdpSignatureTypeValues : ["filler", "author"],
        connectUsageValues : ["exportAndImport", "exportOnly", "importOnly"],
        radialTypeValues : ["toEdge", "toCenter"],
        credentialServerPolicyValues : ["optional", "required"],
        dateTimeEditPickerValues : ["host", "none"],
        bindMatchValues : ["once", "dataRef", "global", "none"],
        runAtValues : ["client", "both", "server"],
        statelessValues : ["0", "1"],
        executeTypeValues : ["import", "remerge"],
        calcOverrideValues : ["disabled", "error", "ignore", "warning" ],
        embedPDFValues : ["0", "1"],
        submitFormatValues : ["xdp", "formdata", "pdf", "urlencoded", "xfd", "xml" ],
        setRelationValues : ["ordered" , "choice" , "unordered"],
        firstTraversal : "first",
        nextTraversal : "next",
        ScribbleImageField : "ScribbleImageField",
        scribbleChangeEvent : "scribbleChange",
        calendarIconMaxWidth : 40

    };
    xfalib.template.Constants = Constants;
})(_,xfalib);
(function(_, xfalib){

var XfaTemplateSchema = {};

var TemplateSchema = xfalib.template.TemplateSchema = xfalib.ut.Class.extend({
    initialize : function() {
        var elem = null;
        XfaTemplateSchema["field"] = elem = this.createElement();
        this.addAttributes(elem,[
                                    ["access",xfalib.template.Constants.accessValues,0],
                                    ["h","measurement",0],
                                    ["w","measurement",0],
                                    ["x","measurement",0],
                                    ["y","measurement",0],
                                    ["presence",xfalib.template.Constants.presenceValues,0],
                                    ["name","string",""],
                                    ["relevant", "string", "" ],
                                    ["locale","string","en_US"]
                                   ]);
        this.addChildren(elem, [
                                    ["items","zeroOrTwo"],
                                    ["extras","zeroOrOne"],
                                    ["desc","zeroOrOne"],
                                    ["event","zeroOrMore"],
                                    ["value","zeroOrOne"],
                                    ["ui","zeroOrOne"],
                                    ["assist","zeroOrOne"],
                                    ["border", "zeroOrOne"]  ,
                                    ["para", "zeroOrOne"]  ,
                                    ["caption", "zeroOrOne"]  ,
                                    ["validate","zeroOrOne"]  ,
                                    ["margin", "zeroOrOne"] ,
                                    ["font", "zeroOrOne"],
                                    ["calculate","zeroOrOne"],
                                    ["format","zeroOrOne"],
                                    ["bindItems","zeroOrMore"]
                                ]);

        XfaTemplateSchema["area"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["x","measurement",0],
            ["y","measurement",0],
            ["relevant", "string", "" ],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["field","zeroOrMore"],
            ["draw","zeroOrMore"],
            ["exclGroup","zeroOrMore"],
            ["instanceManager","zeroOrMore"],
            ["area","zeroOrMore"],
            ["subform","zeroOrMore"],
            ["subformSet","zeroOrMore"]
        ]);

        XfaTemplateSchema["subformSet"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["relation",xfalib.template.Constants.setRelationValues,0],
            ["relevant","string",""],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["bookend","zeroOrOne"],
            ["break","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["extras","zeroOrOne"],
            ["occur","zeroOrOne"],
            ["overflow","zeroOrOne"],
            ["breakAfter","zeroOrMore"],
            ["breakBefore","zeroOrMore"],
            ["instanceManager","zeroOrMore"],
            ["subform","zeroOrMore"],
            ["subformSet","zeroOrMore"]
        ]);

        XfaTemplateSchema["contentArea"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""],
            ["h","measurement",0],
            ["w","measurement",0],
            ["x","measurement",0],
            ["relevant", "string", "" ],
            ["y","measurement",0]
        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"]
        ]);

        XfaTemplateSchema["date"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);

        XfaTemplateSchema["decimal"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""],
            ["leadDigits","integer",-1],
            ["fracDigits","integer",2]
        ]);

        XfaTemplateSchema["draw"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["h","measurement",0],
            ["w","measurement",0],
            ["x","measurement",0],
            ["y","measurement",0],
            ["presence",xfalib.template.Constants.presenceValues,0],
            ["name","string",""],
            ["access", xfalib.template.Constants.accessValues, 0],  // TODO : fix schema violation
            ["relevant", "string", "" ],
            ["locale","string","en_US"]

        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["value","zeroOrOne"],
            ["ui","zeroOrOne"],
            ["border", "zeroOrOne"]  ,
            ["font", "zeroOrOne"]  ,
            ["para", "zeroOrOne"]  ,
            ["caption", "zeroOrOne"]  ,
            ["assist","zeroOrOne"],
            ["font", "zeroOrOne"],
            ["margin", "zeroOrOne"]
        ]);

        XfaTemplateSchema["exclGroup"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["access",xfalib.template.Constants.accessValues,0],
            ["h","measurement",0],
            ["w","measurement",0],
            ["x","measurement",0],
            ["y","measurement",0],
            ["relevant", "string", "" ],
            ["presence",xfalib.template.Constants.presenceValues,0],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["field","zeroOrMore"],
            ["assist","zeroOrOne"],
            ["border", "zeroOrOne"]  ,
            ["para", "zeroOrOne"]  ,
            ["caption", "zeroOrOne"]  ,
            ["validate","zeroOrOne"],
            ["margin", "zeroOrOne"]
        ]);

        XfaTemplateSchema["float"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);

        XfaTemplateSchema["integer"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);

        XfaTemplateSchema["items"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["save",xfalib.template.Constants.itemSaveValues,0],
            ["presence",xfalib.template.Constants.presenceValues,0],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["text","zeroOrMore"],
            ["integer","zeroOrMore"],
            ["date","zeroOrMore"],
            ["decimal","zeroOrMore"],
            ["float","zeroOrMore"]
        ]);

        XfaTemplateSchema["occur"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["initial","integer",1],
            ["max","integer",1],
            ["min","integer",1]
        ]);
        this.addChildren(elem, [
            ["extras","zeroOrOne"]
        ]);

        XfaTemplateSchema["pageArea"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["relevant", "string", "" ],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["occur","zeroOrOne"],
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["area","zeroOrMore"],
            ["field","zeroOrMore"],
            ["draw","zeroOrMore"],
            ["exclGroup","zeroOrMore"],
            ["instanceManager","zeroOrMore"],
            ["subform","zeroOrMore"],
            ["contentArea","zeroOrMore"]
        ]);



        XfaTemplateSchema["pageSet"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["relevant", "string", "" ],
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["occur","zeroOrOne"],
            ["extras","zeroOrOne"],
            ["pageArea","zeroOrMore"],
            ["pageSet","zeroOrMore"]
        ]);

        XfaTemplateSchema["subform"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["access",xfalib.template.Constants.accessValues,0],
            ["h","measurement",0],
            ["w","measurement",0],
            ["x","measurement",0],
            ["y","measurement",0],
            ["presence",xfalib.template.Constants.presenceValues,0],
            ["name","string",""],
            ["relevant", "string", "" ],
            ["locale","string","en_US"]
        ]);
        this.addChildren(elem, [
            ["occur","zeroOrOne"],
            ["extras","zeroOrOne"],
            ["desc","zeroOrOne"],
            ["pageSet","zeroOrOne"],
            ["variables","zeroOrOne"],
            ["area","zeroOrMore"],
            ["field","zeroOrMore"],
            ["draw","zeroOrMore"],
            ["exclGroup","zeroOrMore"],
            ["instanceManager","zeroOrMore"],
            ["subform","zeroOrMore"],
            ["assist","zeroOrOne"],
            ["border", "zeroOrOne"],
            ["para", "zeroOrOne"],
            ["validate","zeroOrOne"],
            ["subformSet","zeroOrMore"],
            ["bind","zeroOrOne"],
            ["margin", "zeroOrOne"]
        ]);

        XfaTemplateSchema["text"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""],
            ["maxChars","integer",0]
        ]);

        XfaTemplateSchema["exData"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""],
            ["maxLength","integer",-1],
            ["transferEncoding",xfalib.template.Constants.transferEncodingValues,0],
            ["contentType","string","text/plain"]
        ]);


        XfaTemplateSchema["extras"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);
        this.addChildren(elem, [
            ["text","zeroOrMore"],
            ["integer","zeroOrMore"],
            ["date","zeroOrMore"],
            ["decimal","zeroOrMore"],
            ["float","zeroOrMore"],
            ["value", "zeroOrOne"],
            ["extras","zeroOrMore"]
        ]);

        XfaTemplateSchema["desc"] = elem = this.createElement();
        this.addChildren(elem, [
            ["text","zeroOrMore"],
            ["integer","zeroOrMore"],
            ["date","zeroOrMore"],
            ["decimal","zeroOrMore"],
            ["float","zeroOrMore"]
        ]);

        XfaTemplateSchema["variables"] = elem = this.createElement();
        this.addChildren(elem, [
            ["boolean","zeroOrMore"],
            ["date","zeroOrMore"],
            ["dateTime","zeroOrMore"],
            ["decimal","zeroOrMore"],
            ["exData","zeroOrMore"],
            ["float","zeroOrMore"],
            ["image","zeroOrMore"],
            ["integer","zeroOrMore"],
            ["manifest","zeroOrMore"],
            ["script","zeroOrMore"],
            ["script","zeroOrMore"],
            ["time","zeroOrMore"]
        ]);


//------------------------------------------------------------------------------------------------------------------------------
        XfaTemplateSchema["para"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hAlign","string","left"],
            ["lineHeight","measurement","0pt"],
            ["marginLeft","measurement","0in"],
            ["marginRight","measurement","0in"],
            ["orphans","integer",0],
            ["preserve","string",""],
            ["radixOffset","measurement","0in"],
            ["spaceAbove","measurement","0in"],
            ["spaceBelow","measurement","0in"],
            ["tabDefault","string",""],
            ["tabStops","string",""],
            ["textIndent","measurement","0in"],
            ["vAlign","string","top"],
            ["widows","integer",0],
            ["wordSpacingMaximum","string",""],
            ["wordSpacingMinimum","string",""],
            ["wordSpacingOptimum","string",""]
        ]);

        XfaTemplateSchema["encryptData"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["operation", xfalib.template.Constants.encryptDataOperationValues, 0 ]  ,
            ["target", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["filter", "zeroOrOne"]  ,
            ["manifest", "zeroOrOne"]
        ]);


        XfaTemplateSchema["issuers"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["certificate", "zeroOrMore"]
        ]);


        XfaTemplateSchema["imageEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["data", xfalib.template.Constants.dataValues, 1 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["bookend"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["leader", "string", "" ]  ,
            ["trailer", "string", "" ]
        ]);


        XfaTemplateSchema["reason"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name","string",""]
        ]);


        XfaTemplateSchema["passwordEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hScrollPolicy", xfalib.template.Constants.hScrollPolicyValues, 0 ]  ,
            ["passwordChar", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["validate"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["disableAll", xfalib.template.Constants.disableAllValues, 0 ]  ,
            ["formatTest", xfalib.template.Constants.formatTestValues, 0 ]  ,
            ["nullTest", xfalib.template.Constants.nullTestValues, 0 ]  ,
            ["scriptTest", xfalib.template.Constants.scriptTestValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["message", "zeroOrOne"]  ,
            ["picture", "zeroOrOne"]  ,
            ["script", "zeroOrOne"]
        ]);


        XfaTemplateSchema["break"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["after", xfalib.template.Constants.afterValues, 0 ]  ,
            ["afterTarget", "string", "" ]  ,
            ["before", xfalib.template.Constants.beforeValues, 0 ]  ,
            ["beforeTarget", "string", "" ]  ,
            ["bookendLeader", "string", "" ]  ,
            ["bookendTrailer", "string", "" ]  ,
            ["overflowLeader", "string", "" ]  ,
            ["overflowTarget", "string", "" ]  ,
            ["overflowTrailer", "string", "" ]  ,
            ["startNew", xfalib.template.Constants.startNewValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["time"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["certificate"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["lockDocument"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);


        XfaTemplateSchema["arc"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["circular", xfalib.template.Constants.circularValues, 0 ]  ,
            ["hand", xfalib.template.Constants.handValues, 0 ]  ,
            ["startAngle", "string", "0" ]  ,
            ["sweepAngle", "string", "360" ]
        ]);
        this.addChildren(elem, [
            ["edge", "zeroOrOne"]  ,
            ["fill", "zeroOrOne"]
        ]);


        XfaTemplateSchema["button"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["highlight", xfalib.template.Constants.highlightValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["event"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["activity", xfalib.template.Constants.activityValues, 0 ]  ,
            ["listen", xfalib.template.Constants.listenValues, 0 ]  ,
            ["name", "string", "" ],
            ["ref", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["encryptData", "oneOfChild"]  ,
            ["execute", "oneOfChild"]  ,
            ["script", "oneOfChild"]  ,
            ["signData", "oneOfChild"]  ,
            ["submit", "oneOfChild"]
        ]);


        XfaTemplateSchema["boolean"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["margin"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["bottomInset", "measurement", "0in" ]  ,
            ["leftInset", "measurement", "0in" ]  ,
            ["rightInset", "measurement", "0in" ]  ,
            ["topInset", "measurement", "0in" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["border"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["break", xfalib.template.Constants.breakValues, 0 ]  ,
            ["hand", xfalib.template.Constants.handValues, 0 ]  ,
            ["presence", xfalib.template.Constants.presenceValues, 0 ]  ,
            ["relevant", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["corner", "zeroOrFour"]  ,
            ["edge", "zeroOrFour"]  ,
            ["extras", "zeroOrOne"]  ,
            ["fill", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["breakAfter"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["leader", "string", "" ]  ,
            ["startNew", xfalib.template.Constants.startNewValues, 0 ]  ,
            ["target", "string", "" ]  ,
            ["targetType", xfalib.template.Constants.targetTypeValues, 0 ]  ,
            ["trailer", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["script", "zeroOrOne"]
        ]);


        XfaTemplateSchema["signature"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.signTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["filter", "zeroOrOne"]  ,
            ["manifest", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["signData"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["operation", xfalib.template.Constants.signDataOperationValues, 0 ]  ,
            ["ref", "string", "" ]  ,
            ["target", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["filter", "zeroOrOne"]  ,
            ["manifest", "zeroOrOne"]
        ]);


        XfaTemplateSchema["image"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["aspect", xfalib.template.Constants.aspectValues, 0 ]  ,
            ["contentType", "string", "" ]  ,
            ["href", "string", "" ]  ,
            ["name", "string", "" ]  ,
            ["transferEncoding", xfalib.template.Constants.transferEncodingValues, 2 ]
        ]);


        XfaTemplateSchema["oids"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["oid", "zeroOrMore"]
        ]);


        XfaTemplateSchema["solid"] = elem = this.createElement();
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["manifest"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["action", xfalib.template.Constants.manifestActionValues, 0 ],
            ["name", "string", "2" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["ref", "zeroOrMore"]
        ]);



        XfaTemplateSchema["traverse"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["delegate", xfalib.template.Constants.traverseDelegateValues, 0 ]  ,
            ["operation", xfalib.template.Constants.traverseOperationValues, 0 ]  ,
            ["ref", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["script", "zeroOrOne"]
        ]);


        XfaTemplateSchema["line"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hand", xfalib.template.Constants.handValues, 0 ]  ,
            ["slope", xfalib.template.Constants.slopeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["edge", "zeroOrOne"]
        ]);


        XfaTemplateSchema["digestMethods"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["digestMethod", "zeroOrMore"]
        ]);


        XfaTemplateSchema["reasons"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["reason", "zeroOrMore"]
        ]);


        XfaTemplateSchema["defaultUi"] = elem = this.createElement();
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["hyphenation"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["excludeAllCaps", xfalib.template.Constants.excludeAllCapsValues, 0 ]  ,
            ["excludeInitialCap", xfalib.template.Constants.excludeInitialCapValues, 0 ]  ,
            ["hyphenate", xfalib.template.Constants.hyphenateValues, 0 ]  ,
            ["ladderCount", "integer", 2 ]  ,
            ["pushCharacterCount", "integer", 3 ]  ,
            ["remainCharacterCount", "integer", 3 ]  ,
            ["wordCharacterCount", "integer", 7 ]
        ]);


        XfaTemplateSchema["rectangle"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hand", xfalib.template.Constants.handValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["corner", "zeroOrFour"]  ,
            ["edge", "zeroOrFour"]  ,
            ["fill", "zeroOrOne"]
        ]);


        XfaTemplateSchema["encryptionMethod"] = elem = this.createElement();


        XfaTemplateSchema["checkButton"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["allowNeutral", xfalib.template.Constants.allowNeutralValues, 0 ]  ,
            ["mark", xfalib.template.Constants.markValues, 0 ]  ,
            ["shape", xfalib.template.Constants.shapeValues, 0 ]  ,
            ["size", "string", "10pt" ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["choiceList"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["commitOn", xfalib.template.Constants.commitOnValues, 0 ]  ,
            ["open", xfalib.template.Constants.openValues, 0 ]  ,
            ["textEntry", xfalib.template.Constants.textEntryValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["oid"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["encoding"] = elem = this.createElement();


        XfaTemplateSchema["ui"] = elem = this.createElement();
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["picture", "zeroOrOne"]  ,
            ["barcode", "oneOfChild"]  ,
            ["button", "oneOfChild"]  ,
            ["checkButton", "oneOfChild"]  ,
            ["choiceList", "oneOfChild"]  ,
            ["dateTimeEdit", "oneOfChild"]  ,
            ["defaultUi", "oneOfChild"]  ,
            ["exObject", "oneOfChild"]  ,
            ["imageEdit", "oneOfChild"]  ,
            ["numericEdit", "oneOfChild"]  ,
            ["passwordEdit", "oneOfChild"]  ,
            ["signature", "oneOfChild"]  ,
            ["textEdit", "oneOfChild"]
        ]);


        XfaTemplateSchema["linear"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.linearTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["edge"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["cap", xfalib.template.Constants.edgeCapValues, 0 ]  ,
            ["presence", xfalib.template.Constants.presenceValues, 0 ]  ,
            ["stroke", xfalib.template.Constants.strokeValues, 0 ]  ,
            ["thickness", "string", "0.5pt" ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["corner"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["inverted", xfalib.template.Constants.cornerInvertedValues, 0 ]  ,
            ["join", xfalib.template.Constants.cornerJoinValues, 0 ]  ,
            ["presence", xfalib.template.Constants.presenceValues, 0 ]  ,
            ["radius", "string", "0in" ]  ,
            ["stroke", xfalib.template.Constants.strokeValues, 0 ]  ,
            ["thickness", "string", "0.05pt" ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["toolTip"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["rid", "string", "" ]
        ]);


        XfaTemplateSchema["speak"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["disable", xfalib.template.Constants.speakDisableValues, 0 ]  ,
            ["priority", xfalib.template.Constants.speakPriorityValues, 0 ]  ,
            ["rid", "string", "" ]
        ]);


        XfaTemplateSchema["caption"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["placement", xfalib.template.Constants.captionPlacementValues, 0 ]  ,
            ["presence", xfalib.template.Constants.presenceValues, 0 ]  ,
            ["reserve", "string", "-1" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["font", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]  ,
            ["para", "zeroOrOne"]  ,
            ["value", "zeroOrOne"]
        ]);


        XfaTemplateSchema["comb"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["numberOfCells", "integer", 0 ]
        ]);


        XfaTemplateSchema["medium"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["imagingBBox", "string", "" ]  ,
            ["long", "string", "0in" ]  ,
            ["orientation", xfalib.template.Constants.orientationValues, 0 ]  ,
            ["short", "string", "0in" ]  ,
            ["stock", "string", "" ]  ,
            ["trayIn", xfalib.template.Constants.mediumTrayInValues, 0 ]  ,
            ["trayOut", xfalib.template.Constants.mediumTrayOutValues, 0 ]
        ]);


        XfaTemplateSchema["ref"] = elem = this.createElement();


        XfaTemplateSchema["pattern"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.patternTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["keep"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["intact", xfalib.template.Constants.keepIntactValues, 0 ]  ,
            ["next", xfalib.template.Constants.keepNextValues, 0 ]  ,
            ["previous", xfalib.template.Constants.keepPreviousValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["digestMethod"] = elem = this.createElement();


        XfaTemplateSchema["signing"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["certificate", "zeroOrMore"]
        ]);


        XfaTemplateSchema["encryption"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["certificate", "zeroOrMore"]
        ]);


        XfaTemplateSchema["subjectDNs"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["subjectDN", "zeroOrMore"]
        ]);


        XfaTemplateSchema["encrypt"] = elem = this.createElement();
        this.addChildren(elem, [
            ["certificate", "zeroOrOne"]
        ]);


        XfaTemplateSchema["value"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["override", xfalib.template.Constants.valueOverrideValues, 0 ]  ,
            ["relevant", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["arc", "oneOfChild"]  ,
            ["boolean", "oneOfChild"]  ,
            ["date", "oneOfChild"]  ,
            ["dateTime", "oneOfChild"]  ,
            ["decimal", "oneOfChild"]  ,
            ["exData", "oneOfChild"]  ,
            ["float", "oneOfChild"]  ,
            ["image", "oneOfChild"]  ,
            ["integer", "oneOfChild"]  ,
            ["line", "oneOfChild"]  ,
            ["rectangle", "oneOfChild"]  ,
            ["text", "oneOfChild"]  ,
            ["time", "oneOfChild"]
        ]);


        XfaTemplateSchema["traversal"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["passThrough", xfalib.template.Constants.passThroughValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["traverse", "zeroOrMore"]
        ]);


        XfaTemplateSchema["textEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["allowRichText", xfalib.template.Constants.allowRichTextValues, 0 ]  ,
            ["hScrollPolicy", xfalib.template.Constants.hScrollPolicyValues, 0 ]  ,
            ["multiLine", xfalib.template.Constants.multiLineValues, 1 ]  ,
            ["vScrollPolicy", xfalib.template.Constants.vScrollPolicyValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["comb", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["stipple"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["rate", "integer", 50 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["font"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["baselineShift", "string", "0in" ]  ,
            ["fontHorizontalScale", "string", "" ]  ,
            ["fontVerticalScale", "string", "" ]  ,
            ["kerningMode", xfalib.template.Constants.kerningModeValues, 0 ]  ,
            ["letterSpacing", "string", "" ]  ,
            ["lineThrough", xfalib.template.Constants.lineThroughValues, 0 ]  ,
            ["lineThroughPeriod", xfalib.template.Constants.lineThroughPeriodValues, 0 ]  ,
            ["overline", xfalib.template.Constants.fontOverlineValues, 0 ]  ,
            ["overlinePeriod", xfalib.template.Constants.fontOverlinePeriodValues, 0 ]  ,
            ["posture", xfalib.template.Constants.postureValues, 0 ]  ,
            ["size", "string", "10pt" ]  ,
            ["typeface", "string", "" ]  ,
            ["underline", xfalib.template.Constants.underlineValues, 0 ]  ,
            ["underlinePeriod", xfalib.template.Constants.underlinePeriodValues, 0 ]  ,
            ["weight", xfalib.template.Constants.fontWeightValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["fill", "zeroOrOne"]
        ]);


        XfaTemplateSchema["barcode"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["charEncoding", "string", "" ]  ,
            ["checksum", xfalib.template.Constants.checksumValues, 0 ]  ,
            ["dataColumnCount", "string", "" ]  ,
            ["dataLength", "string", "" ]  ,
            ["dataPrep", xfalib.template.Constants.dataPrepValues, 0 ]  ,
            ["dataRowCount", "string", "" ]  ,
            ["endChar", "string", "" ]  ,
            ["errorCorrectionLevel", "string", "" ]  ,
            ["moduleHeight", "string", "5mm" ]  ,
            ["moduleWidth", "string", "0.25mm" ]  ,
            ["printCheckDigit", xfalib.template.Constants.printCheckDigitValues, 0 ]  ,
            ["rowColumnRatio", "string", "" ]  ,
            ["startChar", "string", "" ]  ,
            ["textLocation", xfalib.template.Constants.textLocationValues, 0 ]  ,
            ["truncate", xfalib.template.Constants.truncateValues, 0 ]  ,
            ["type", "string", "" ]  ,
            ["upsMode", xfalib.template.Constants.upsModeValues, 0 ]  ,
            ["wideNarrowRatio", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["encrypt", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["assist"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["role", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["speak", "zeroOrOne"]  ,
            ["toolTip", "zeroOrOne"]
        ]);


        XfaTemplateSchema["breakBefore"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["leader", "string", "" ]  ,
            ["startNew", xfalib.template.Constants.startNewValues, 0 ]  ,
            ["target", "string", "" ]  ,
            ["targetType", xfalib.template.Constants.targetTypeValues, 0 ]  ,
            ["trailer", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["script", "zeroOrOne"]
        ]);


        XfaTemplateSchema["format"] = elem = this.createElement();
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["picture", "zeroOrOne"]
        ]);


        XfaTemplateSchema["keyUsage"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["crlSign", "string", "" ]  ,
            ["dataEncipherment", "string", "" ]  ,
            ["decipherOnly", "string", "" ]  ,
            ["digitalSignature", "string", "" ]  ,
            ["encipherOnly", "string", "" ]  ,
            ["keyAgreement", "string", "" ]  ,
            ["keyCertSign", "string", "" ]  ,
            ["keyEncipherment", "string", "" ]  ,
            ["nonRepudiation", "string", "" ]  ,
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);



        XfaTemplateSchema["picture"] = elem = this.createElement();

        XfaTemplateSchema["mdp"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["permissions", xfalib.template.Constants.mdpPermissionsValues, 0 ]  ,
            ["signatureType", xfalib.template.Constants.mdpSignatureTypeValues, 0 ]
        ]);


        XfaTemplateSchema["overflow"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["leader", "string", "" ]  ,
            ["target", "string", "" ]  ,
            ["trailer", "string", "" ]
        ]);


        XfaTemplateSchema["numericEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hScrollPolicy", xfalib.template.Constants.hScrollPolicyValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["comb", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["appearanceFilter"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);


        XfaTemplateSchema["filter"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["addRevocationInfo", "string", "" ]  ,
            ["name", "string", "" ],
            ["version", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["appearanceFilter", "zeroOrOne"]  ,
            ["certificates", "zeroOrOne"]  ,
            ["digestMethods", "zeroOrOne"]  ,
            ["encodings", "zeroOrOne"]  ,
            ["encryptionMethods", "zeroOrOne"]  ,
            ["handler", "zeroOrOne"]  ,
            ["lockDocument", "zeroOrOne"]  ,
            ["mdp", "zeroOrOne"]  ,
            ["reasons", "zeroOrOne"]  ,
            ["timeStamp", "zeroOrOne"]
        ]);


        XfaTemplateSchema["renderAs"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["APIVersion", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["svg", "zeroOrOne"]
        ]);


        XfaTemplateSchema["timeStamp"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["server", "string", "" ]  ,
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);


        XfaTemplateSchema["connect"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["connection", "string", "" ]  ,
            ["ref", "string", "" ]  ,
            ["usage", xfalib.template.Constants.connectUsageValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["picture", "zeroOrOne"]
        ]);


        XfaTemplateSchema["dateTime"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["bindItems"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["connection", "string", "" ]  ,
            ["labelRef", "string", "" ]  ,
            ["ref", "string", "" ]  ,
            ["valueRef", "string", "" ]
        ]);


        XfaTemplateSchema["encodings"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["encoding", "zeroOrMore"]
        ]);


        XfaTemplateSchema["radial"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.radialTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["certificates"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["credentialServerPolicy", xfalib.template.Constants.credentialServerPolicyValues, 0 ]  ,
            ["url", "string", "" ]  ,
            ["urlPolicy", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["encryption", "zeroOrOne"]  ,
            ["issuers", "zeroOrOne"]  ,
            ["keyUsage", "zeroOrOne"]  ,
            ["oids", "zeroOrOne"]  ,
            ["signing", "zeroOrOne"]  ,
            ["subjectDNs", "zeroOrOne"]
        ]);


        XfaTemplateSchema["svg"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["height", "string", "" ]  ,
            ["viewBox", "string", "" ]  ,
            ["width", "string", "" ]
        ]);


        XfaTemplateSchema["fill"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["presence", xfalib.template.Constants.presenceValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["color", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["linear", "oneOfChild"]  ,
            ["pattern", "oneOfChild"]  ,
            ["radial", "oneOfChild"]  ,
            ["solid", "oneOfChild"]  ,
            ["stipple", "oneOfChild"]
        ]);


        XfaTemplateSchema["setProperty"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["connection", "string", "" ]  ,
            ["ref", "string", "" ]  ,
            ["target", "string", "" ]
        ]);


        XfaTemplateSchema["encryptionMethods"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["encryptionMethod", "zeroOrMore"]
        ]);


        XfaTemplateSchema["dateTimeEdit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["hScrollPolicy", xfalib.template.Constants.hScrollPolicyValues, 0 ]  ,
            ["picker", xfalib.template.Constants.dateTimeEditPickerValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["border", "zeroOrOne"]  ,
            ["comb", "zeroOrOne"]  ,
            ["extras", "zeroOrOne"]  ,
            ["margin", "zeroOrOne"]
        ]);


        XfaTemplateSchema["message"] = elem = this.createElement();
        this.addChildren(elem, [
            ["text", "zeroOrMore"]
        ]);


        XfaTemplateSchema["color"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["cSpace", "string", "SRGB" ]  ,
            ["value", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]
        ]);


        XfaTemplateSchema["subjectDN"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["delimiter", "string", "" ],
            ["name", "string", "" ]
        ]);


        XfaTemplateSchema["bind"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["match", xfalib.template.Constants.bindMatchValues, 0 ]  ,
            ["ref", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["picture", "zeroOrOne"]
        ]);


        XfaTemplateSchema["handler"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["type", xfalib.template.Constants.requiredTypeValues, 0 ]
        ]);


        XfaTemplateSchema["occur"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["initial", "integer", 1 ]  ,
            ["max", "integer", 1 ]  ,
            ["min", "integer", 1 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["script", "zeroOrOne"]
        ]);

        XfaTemplateSchema["script"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["binding", "string", "" ]  ,
            ["contentType", "string", "" ]  ,
            ["name", "string", "" ],
            ["runAt", xfalib.template.Constants.runAtValues, 0 ]  ,
            ["stateless", xfalib.template.Constants.statelessValues, 0 ]
        ]);

        XfaTemplateSchema["execute"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["connection", "string", "" ]  ,
            ["executeType", xfalib.template.Constants.executeTypeValues, 0 ]  ,
            ["runAt", xfalib.template.Constants.runAtValues, 0 ]
        ]);

        XfaTemplateSchema["calculate"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["override", xfalib.template.Constants.calcOverrideValues, 0 ]
        ]);
        this.addChildren(elem, [
            ["extras", "zeroOrOne"]  ,
            ["message", "zeroOrOne"]  ,
            ["script", "zeroOrOne"]
        ]);

        XfaTemplateSchema["submit"] = elem = this.createElement();
        this.addAttributes(elem,[
            ["embedPDF", xfalib.template.Constants.embedPDFValues, 0 ]  ,
            ["format", xfalib.template.Constants.submitFormatValues, 0 ]  ,
            ["target", "string", "" ]  ,
            ["textEncoding", "string", "" ]  ,
            ["xdpContent", "string", "" ]
        ]);
        this.addChildren(elem, [
            ["encrypt", "zeroOrOne"]  ,
            ["encryptData", "zeroOrMore"]  ,
            ["signData", "zeroOrMore"]
        ]);

    },

    addAttributes: function(element,attrArray) {
        _.each(attrArray, function(elem) {
            element.attributes[elem[0]] = {
                                        type:elem[1],
                                        "default":elem[2]
                                       }
        });
    },

    addChildren: function(element,childrenArray) {
        _.each(childrenArray, function(elem) {
            element.children[elem[0]] = {
                relation : xfalib.template.Constants[elem[1]]
            };
        });
    },

    createElement: function() {
        return {attributes: {},children: {}};
    },

    getDefaultAttribute: function(element,attribute) {
        var elem =  XfaTemplateSchema[element];
        if(!elem)
            return "";
        var attr = elem.attributes[attribute];
        if(!attr)
            return undefined;
        if(attr.type instanceof Array) {
            return attr.type[attr["default"]];
        } else
            return attr["default"];
    },

    hasAttribute: function (element, attribute) {
        var elem = XfaTemplateSchema[element];
        if (!elem) {
            return false;
        }
        return _.has(elem.attributes, attribute);
    },

    getChildren : function(element){
        if(XfaTemplateSchema[element])
            return XfaTemplateSchema[element].children;
        else
            return null;
    },

    _getRelation: function(parent,child) {
       var p = XfaTemplateSchema[parent];
       if(!p)
          return null;
       var c = p.children[child]
       if(c)
           return c.relation;
       return null;
    },

    _getDataType: function(element,attribute) {
        var attr =  XfaTemplateSchema[element].attributes[attribute];
        return attr.type;
    },

    _getOneOfChild: function(element) {
        var res = {};
        _.each(XfaTemplateSchema[element].children,
            function(obj,clas) {
                if(obj.relation.type == "oneOfChild")
                    res[clas] = true
            });
        return res;
    }

});
})(_, xfalib);
/**
 * @package xfalib.ut.Version
 * @import xfalib.ut.Class
 */

(function(_, xfalib){
    var Version = xfalib.ut.Version = xfalib.ut.Class.extend({

        ES4: 1100,
        ES4SP1: 1101,
        P9A: 1102, //added new version for P9A -> not being used but still if we need someday

        current: function() {
            return this.P9A;
        },

        initialize : function(options){
            Version._super.initialize.call(this);
            this._originalVersion = options != null ? options.originalVersion : this.current();
            this._override = options ? options.override : {} ;
            if(!this._override) {
                this._override = {};
            }
        },


        isSame : function(v) {
            return (this._originalVersion == v);
        },

        isAfter: function(v) {
            return (this._originalVersion > v);
        },

        isAfterOrSame : function(v) {
            return this.isAfter(v) || this.isSame(v);
        },

        isPrevious: function(v) {
            return (this._originalVersion < v);
        },

        isPreviousOrSame : function(v) {
            return this.isPrevious(v) || this.isSame(v);
        },

        isOn : function(flag) {
            //function to control if a particular flag is on
            //since it might dependent on version so it is in Version class
           return(this._override[flag]);
        }

    });
})(_, xfalib);
(function(_,xfalib){
    xfalib.script.mixin.AddAssist = {
        propertyDescriptors : {
            "assist" : {
                get : function() {
                    return this.getElement("assist", 0);
                },

                set : function(value) {
                    return this.setElement(value, "assist");
                }
            }
        }
    }
})(_, xfalib);


(function(_,xfalib){
    xfalib.script.mixin.AddBorder = {
        propertyDescriptors : {
            "border" : {
                get : function() {
                    return this.getElement("border", 0);
                },

                set : function(value) {
                    return this.setElement(value, "border");
                }
            }
        }
    }
})(_, xfalib);


(function(_,xfalib){
    xfalib.script.mixin.AddCaption = {
        propertyDescriptors : {
            "caption" : {
                get : function() {
                    return this.getElement("caption", 0);
                },

                set : function(value) {
                    return this.setElement(value, "caption");
                }
            }
        }
    }
})(_, xfalib);


(function(_,xfalib){
    xfalib.script.mixin.AddPresence = {
        propertyDescriptors : {
            "presence" : {
                get : function() {
                    //Avoided getAttribute call to avoid any regression in case something is missing in Template Schema
                    return this.getOrElse(this.jsonModel.presence, xfalib.script.Node.prototype._defaults.presence);
                },
                set : function(sPresence) {
                    var oldPresence = this.jsonModel.presence;
                    this.setAttribute(sPresence, "presence");
                    if (this.jsonModel.presence != oldPresence) {
                        this._calculateEffectivePresence();
                        var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                            this,"presence",oldPresence,this.jsonModel.presence);
                        this.trigger(evnt.name,evnt);
                    }
                }
            }
        }
    }
})(_,xfalib);

(function(_,xfalib){
    xfalib.script.mixin.AddXYWH = {
        propertyDescriptors : {
            "h" : {
                get : function() {
                    return this.getOrElse(this.jsonModel.h, xfalib.script.Node.prototype._defaults.h);
                },
                set : function(value) {
                    this.setAttribute(value,"h");
                    var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                               this,"h",value, value);
                    this.trigger(event.name,event);
                }
            },

            "w" : {
                get : function() {
                    return this.getOrElse(this.jsonModel.w, xfalib.script.Node.prototype._defaults.w);
                },
                set : function() {

                }
            },

            "x" : {
                get : function() {
                    return this.getOrElse(this.jsonModel.x, xfalib.script.Node.prototype._defaults.x);
                },
                set : function() {

                }
            },

            "y" : {
                get : function() {
                    return this.getOrElse(this.jsonModel.y, xfalib.script.Node.prototype._defaults.y);
                },
                set : function() {

                }
            }
        }
    }
})(_,xfalib);

(function(_,xfalib){
    xfalib.script.mixin.AddFillColor = {
        propertyDescriptors : {
            "fillColor" : {
                get : function() {
                   return (this.border.fill.color.value == "") ? "255,255,255" : this.border.fill.color.value;
                },

                set : function(color) {
                    if(this.border && this.border.fill && this.border.fill.color) {
                        this.border.fill.presence="visible";
                        this.border.fill.color.value = color;
                    }
                }
            }
        }
    }
})(_,xfalib);
(function(_,xfalib){
    xfalib.script.mixin.AddBorderColor = {
        propertyDescriptors : {
            "borderColor" : {
                get : function() {
                    return this.border.edge.color.value;
                },

                set : function(color) {
                    //TODO: Set border.edge.presence property to visible once Border is implemented
                    this.border.edge.color.value = color ;
                }
            }
        }
    }
})(_, xfalib);

(function(_,xfalib){
    xfalib.script.mixin.AddBorderWidth = {
        propertyDescriptors : {
            "borderWidth" : {
                get : function() {
                    return this.border.edge.thickness;
                },
                set : function(value) {
                    this.border.edge.thickness = value ;
                }
            }
        }
    }
})(_, xfalib);(function(_,xfalib){
    xfalib.script.mixin.AddPara = {
        propertyDescriptors : {
            "para" : {
                get : function() {
                    return this.getElement("para", 0);
                },

                set : function(value) {
                    return this.setElement(value, "para");
                }
            }
        }
    }
})(_, xfalib);


(function(_,xfalib){
    xfalib.script.mixin.AddMargin = {
        propertyDescriptors : {
            "margin" : {
                get : function() {
                    return this.getElement("margin", 0);
                },

                set : function(value) {
                    return this.setElement(value, "margin");
                }
            }
        }
    }
})(_, xfalib);


/**
 * @package xfalib.script.Object
 * @import xfalib.ut.EventClass
 * @fileOverview The file creates the Object Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new class
     * @class Base XFA class. All the other classes are a subclass of this.
     * @constructor
     * @property {string} className represents the name of the class for this object
     */
    var xfaObject = xfalib.script.Object = xfalib.ut.EventClass.extend({
        msClassName : "object",
        initialize : function(){
            //For perf reason, we are computing className at intialize time instead of accessing it via propertyDescriptor
            this.className = this.jsonModel._class || this.msClassName;
        }
    });

})(_, xfalib);
/**
 * @package xfalib.script.XfaList
 * @import xfalib.ut.Class
 */

(function(_, xfalib){
    var XfaList = xfalib.script.XfaList = xfalib.ut.Class.extend({

        initialize : function() {
            XfaList._super.initialize.call(this);
            this.currentIndex = -1;
            this.moArraylist =  new Array();
            this.mParent = this.options.parent;
        },

        item : function(nIndex) {
            if(nIndex <= this.currentIndex)
                return this.moArraylist[nIndex];
            return null;
        },

        _append : function(oParam) {
            this.moArraylist[++this.currentIndex] = oParam;
        },

        append : function(oParam) {
            if(this.mParent && this.mParent instanceof xfalib.script.DOMElement)   {
                var relation = this.mParent._xfa()._templateSchema._getRelation(this.mParent.className,oParam.className);
                switch(relation.type)
                 {
                 case "zeroOrOne":
                 break;
                 case "zeroOrTwo":
                 break;
                 case "zeroOrMore":
                this.mParent._addChild(oParam);
                break;
                 default:

                 }

            }
            this._append(oParam);
        },

        remove : function(oParam) {
            var index = this.moArraylist.indexOf(oParam);
            if(index >= 0) {
                this.moArraylist.splice(index,1);
                this.currentIndex--;
            }
        },

        insert : function(oInsert,oBefore) {
            var index = this.moArraylist.indexOf(oBefore);
            this.currentIndex++;
            if(index <= 0)
                index = this.currentIndex;
            this.moArraylist.splice(index,0,oInsert);
        },

        _concat : function(oList) {
            if(oList == null)
                return;
            for(var i =0; i< oList.length;i++) {
                this._append(oList.item(i));
            }
        },

        namedItem : function(oParam){
            var node = this._find(function(obj) {
                return obj.getAttribute("name") === oParam;
            });
            if(node === undefined) return null;
            return node;
        },

        _find : function(fn) {
            return _.find(this.moArraylist,fn);
        },

        _filter : function(fn) {
            return _.filter(this.moArraylist,fn);
        }
    });

    XfaList.defineProps({
        "length" : {
            get : function() {
                return this.moArraylist.length;
            }
        }
    });
})(_, xfalib);

/**
 * @package xfalib.script.SOMExpression
 * @import xfalib.ut.Class
 */
 
(function(_, xfalib){
    var SOMExpression = xfalib.script.SOMExpression = xfalib.ut.Class.extend({
        initialize : function() {
            SOMExpression._super.initialize.call(this);
            // Format: subformA[n|*]
            // Format: subformA[n|*].[predicate expr]
            // Format: subformA.[predicate expr]
            // predicate expr: boolean expression that may include object references and
            // SOMExpressions

            this._expr = this.options.expression;
            this.scalerMatch = null;
            this.predicate = null;
            this.name = this.options.expression;
            this.index = this.options.defaultOccurrence;
            this._bDefaultIndex = true;
            this._matchCount = 0;

            var arr = this._parseExpression(this.options.expression);
            if (arr == null)
                return;

            if (arr.length == 1)
                this.name = arr[0];
            else if (arr.length == 2) {
                this.name = arr[0];
                if (arr[1] != '') {
                    // Strip brackets
                    var occ = arr[1].substring(1, arr[1].length - 1);
                    if (occ == '*')
                        this.index = '*';
                    else
                        this.index = parseInt(occ);

                    this._bDefaultIndex = false;
                }
            } else if (arr.length == 3) {
                this.name = arr[0];
                if (this.options.ignorePredicate == false) {
                    // Strip brackets
                    this.predicate = arr[2].substring(1, arr[2].length - 1);
                    this.index = '*';
                }
            }
        },

        equals : function(obj) {
          return this.namesEqual(obj) || this.classesEqual(obj);
        },

        evalPredicate : function (obj) {
            // Default: true, indicating obj passes pred expr qualification
            var bPredicateResult = true;

            //TODO: Implement later
            /*
             if (this.predicate != null && obj != null)
             {
             var parser:KParser = new KParser();
             var result:Object = parser.evaluateExpression (this.predicate, obj);
             if (result is Boolean)
             {
             trace ("evalPredicate() on: " + this.predicate + ", result: " + result);
             bPredicateResult = result;
             }
             }
             */
            return bPredicateResult;
        },

        namesEqual : function(obj) {
            if (this.name == obj.getAttribute("name")){
                var bPredResult = this.evalPredicate(obj);

                if (((this.index == '*') || (this.index == obj.index)) && bPredResult == true)
                    return true;

                //
                // If the SOM expression does not have a specific index
                // record a name match with the obj with the lowest index
                //
                if (this._bDefaultIndex && bPredResult)
                {
                    if ((this.scalerMatch == null) || (obj.index < this.scalerMatch.index))
                        this.scalerMatch = obj;
                }
            }
            return false;
        },

        classesEqual : function ( obj){
            var bRet = false;
            var bPredResult = this.evalPredicate(obj);

            if (this.name == "#"+obj.className){
                if (this.index == '*' && bPredResult == true){
                    bRet = true;
                }
                else{
                    if (this.index == obj.mnClassIndex && bPredResult == true)
                        bRet = true;
                    else
                        bRet = false;
                }
            }
            return bRet;
        },

        tagEquals : function (obj) {
            var parent = obj.parent;
            var max;
            if(parent) {
                try {
                    var relation = parent._getRelation(obj);
                    if(relation)
                        max = relation.max;
                }
                catch(e) {
                    this._xfa().Logger.debug("xfa", "incomplete schema.");
                }
            }
            //if this obj is the only possible child of its type then ignore class index.
            return this.name == obj.className && (max == 1 || this.index =='*' || this.index == obj.mnClassIndex)
        },

        _parseExpression : function(sSomExpression) {
            if (sSomExpression == null) {
                return null;
            }

            var arr = [];
            var buf = "";
            var inBrace = 0;
            var bEscape = false;
            for ( var j = 0; j < sSomExpression.length; j++) {
                var s = sSomExpression.charAt(j);
                if (s == "[" && !inBrace) {
                    inBrace++;
                    arr.push(buf);
                    buf = "";
                }
                if (s == "[" && inBrace) {
                    inBrace++;
                    buf += s;
                } else if (s == "]" && inBrace) {
                    --inBrace;
                    buf += s;
                } else if (s == "\\") {
                    bEscape = true;
                } else if (s == "." && !inBrace && !bEscape) {
                    arr.push(buf);
                    buf = "";
                } else {
                    buf += s;
                    bEscape = false;
                }

                if (j == sSomExpression.length - 1)
                    arr.push(buf);
            }
            return arr;
        },

        splitExpression : function(sSomExpression) {
            if (sSomExpression == null)
                return null;

            var arr = [];
            var buf = "";
            var inBrace = 0;
            var bEscape = false;
            for ( var j = 0; j < sSomExpression.length; j++) {
                var s = sSomExpression.charAt(j);
                if (s == "[") {
                    inBrace++;
                    buf += s;
                } else if (s == "]") {
                    --inBrace;
                    buf += s;
                } else if (s == "\\") {
                    bEscape = true;
                    buf += s;
                } else if (s == "." && inBrace == 0 && bEscape == false) {
                    if (buf.length == 0)
                        arr.push(".."); // elipsis
                    else {
                        if (buf.indexOf("#variables") < 0) {
                            arr.push(buf);
                        }
                    }
                    buf = "";
                } else {
                    buf += s;
                    bEscape = false;
                }

                if (j == sSomExpression.length - 1) {
                    if (buf.indexOf("#variables") < 0) {
                        arr.push(buf);
                    }
                }
            }

            if (arr.length == 1)
                return arr;

            var out = [];
            var pattern = /^\[.*\]/;
            for ( var i = 0; i < arr.length; i++) {
                var seg = String(arr[i]);
                if (seg.match(pattern) && i > 0)
                    out.splice(i - 1, 1, arr[i - 1] + "." + seg);
                else
                    out.push(arr[i]);
            }
            return out;
        }

    });

    SOMExpression.defineProps({
        "expression" : {
            get : function() {
                return this._expr;
            },
            set : function(expression) {            	
            	expression = this.validateInput(expression,"string");
                this._expr = expression;
            }
        }
    });

})(_, xfalib);



/**
 * @package xfalib.script.XfaModelEvent
 * @import xfalib.script.Object
 * @fileOverview The file creates the XfaModelEvent Class required for XFA library
 * @version 0.0.1
 */
(function(_,xfalib) {

    var XfaModelEvent = xfalib.script.XfaModelEvent = xfalib.script.Object.extend({
        msClassName: "eventPseudoModel"
    });

    XfaModelEvent.defineProps({
        "prevText" : {
            get : function(){
                return this.jsonModel.prevText;
            }
        },
        "newText" : {
            get : function(){
                return this.jsonModel.newText;
            }
        },
        "fullText": {
            get: function () {
                return this.jsonModel.fullText;
            }
        },
        "name" : {
            get : function(){
                return this.jsonModel.name;
            }
        },
        "keyDown" : {
            get : function(){
                return this.jsonModel.keyDown;
            }
        },
        "modifier" : {
            get : function(){
                return this.jsonModel.modifier;
            }
        },
        "target" : {
            get : function(){
                return this.jsonModel.target;
            }
        },
        "shift" : {
            get : function(){
                return this.jsonModel.shift;
            }
        },
        "change" : {
            get : function(){
                return this.jsonModel.change;
            },
            set : function(value){
                this.jsonModel.change = value;
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,this.target,
                    'change',value,null);
                this.target.trigger(evnt.name,evnt);
            }
        },
        "_property" : {
            get : function(){
                return this.jsonModel._property;
            },

            set : function(value){
                this.jsonModel._property = value;
            }
        }
    });

    XfaModelEvent.createEvent = function(nm,tgt,prop,oldVal,newVal) {
        var evnt = {
            name:nm,
            target:tgt,
            _property:prop,
            prevText:oldVal,
            newText:newVal
        };
        return new XfaModelEvent({"jsonModel" : evnt});
    };

    XfaModelEvent.FORM_MODEL_CHANGED = "formModelChanged";
    XfaModelEvent.RAW_VALUE_CHANGED = "rawValueChanged";
    XfaModelEvent.CHILD_ADDED = "childAdded";
    XfaModelEvent.CHILD_REMOVED = "childRemoved";
    XfaModelEvent.CHILD_MOVED = "childMoved";
    XfaModelEvent.OBJECT_DESTROYED = "objectDestroyed";
    XfaModelEvent.FORM_MODEL_REFRESH = "formModelRefresh";
    XfaModelEvent.DOM_CHANGED = "domChanged";
})(_,xfalib);
/**
 * @package xfalib.script.Layout
 * @import xfalib.script.Class
 */

(function(_, xfalib){
    var Layout = xfalib.script.Layout = xfalib.ut.Class.extend({
        initialize : function(){
            this.pagingManager = null ;
            Layout._super.initialize.call(this);

        },

        _xfa : function() {
            return xfalib.script.Xfa.Instance;
        },

        relayout: function() {
        },

        page: function(node){
            return this.pagingManager.findPage(node.htmlId) + 1;
        },

        pageCount: function() {
            if(this.pagingManager)
                return(this.pagingManager.pageCount());
        },

        absPageCount: function() {
            if(this.pagingManager)
                return(this.pagingManager.pageCount());
        },

        pageContent : function(pageNum, className, bPageArea){
            if(this.pagingManager){
                return this.pagingManager._pageContent(pageNum, className, bPageArea);
            }
            else
                return new xfalib.script.XfaList();
        },

        px2pt: function(px) {
            return px/2;
        },

        pt2inch: function(pt) {
            return pt/72;
        },

        pt2mm: function(pt) {
            return (pt*25.4)/72;
        },

        h: function(node, unit, offset) {
            if(this.pagingManager)    {
                this.pagingManager._makePageForHtmlId(node.htmlId);
                var layout = this.pagingManager.getLayout(node.htmlId);
                if(layout) {
                    var h = this.px2pt(layout.extenth) ;
                    if(unit == "inch" || unit == "in")
                        h = this.pt2inch(h);
                    if(unit == "mm")
                        h = this.pt2mm(h);
                    if(offset != undefined)
                        h= 0;
                    return h;
                }
                else return 0;

            }

        },

        w: function(node, unit, offset) {
            if(this.pagingManager)    {
                this.pagingManager._makePageForHtmlId(node.htmlId);
                var layout = this.pagingManager.getLayout(node.htmlId);
                if(layout)      {
                    var w = this.px2pt(layout.extentw) ;
                    if(unit == "inch" || unit == "in")
                        w = this.pt2inch(w);
                    if(unit == "mm")
                        w = this.pt2mm(w);
                    if(offset != undefined)
                        w= 0;
                    return w ;
                }
                else return 0;

            }
        },

        x: function(node, unit, offset) {
            if(this.pagingManager)    {
                this.pagingManager._makePageForHtmlId(node.htmlId);
                var layout = this.pagingManager.getLayout(node.htmlId);
                if(layout){
                    var x = this.px2pt(layout.extentx) ;
                    if(unit == "inch" || unit == "in")
                        x = this.pt2inch(x);
                    if(unit == "mm")
                        x = this.pt2mm(x);
                    if(offset != undefined)
                        x= 0;
                    return x;
                }
                else return 0;

            }
        },

        y: function(node, unit, offset) {
            if(this.pagingManager)    {
                this.pagingManager._makePageForHtmlId(node.htmlId);
                var layout = this.pagingManager.getLayout(node.htmlId);
                if(layout){
                    var y = this.px2pt(layout.extenty) ;
                    if(unit == "inch" || unit == "in")
                        y = this.pt2inch(y);
                    if(unit == "mm")
                        y = this.pt2mm(y);
                    if(offset != undefined)
                        y= 0;
                    return y;
                }
                else return 0;

            }
        }

    });
    Layout.defineProps({
        "ready" : {
            get : function(){
                return true;
            }
        }
    });
})(_, xfalib);

/**
 * @package xfalib.script.Node
 * @import xfalib.script.Object
 * @import xfalib.script.SOMExpression
 * @import xfalib.script.XfaList
 * @fileOverview The file creates the Node Class required for XFA library
 * @version 0.0.1
 */


(function(_, xfalib){
    var Node = xfalib.script.Node = xfalib.script.Object.extend({
        _defaults : {
            "presence" : "visible"
        },

        initialize : function(){
            Node._super.initialize.call(this);
            /**
             * @private
             * @type xfalib.script.Node
             */
            this.mParent = null;
            /**
             * @private
             * @type string
             */
            this.mnIndex = 0;
            /**
             * @private
             * @type string
             */
            this.mnClassIndex = 0;
        },

        playJson : function(pJsonModel) {
            // tabIndex should be exempted because we are already computing it in _insert Instance
            // CQ-4324970: replace default FS_DATA_SOM present in FS_EXTRAS with dataSom present in extras for repeated elements.
            this.setFsDataSom(pJsonModel);
            this.copyObject(pJsonModel, this.jsonModel, {exceptions : ["htmlId", "children","tabIndex"], keepReference : true});
        },

        setFsDataSom : function(pJsonModel) {
            if (window.FD && window.FD.isToggleEnabled("FT_FORMS-14349")) { // FORMS-10731 : don't change FS_DATA_SOM if field is not named.
                this.setFsDataSomValue(pJsonModel);
            } else {
                if (this.getAttribute("name") && this.getAttribute("name").length > 0) {
                    this.setFsDataSomValue(pJsonModel);
                }
            }
        },

        setFsDataSomValue : function(pJsonModel) {
            var fsDataSom = this.resolveNode("#extras.FS_EXTRAS.FS_DATA_SOM");
            if (fsDataSom && pJsonModel.extras && pJsonModel.extras.dataSom) {
                fsDataSom.value = pJsonModel.extras.dataSom;
            }
        },

        //TODO: REMOVE this when the actual implementation is available
        saveXML : function() {
            return "";
        },

        //TODO: REMOVE this when the actual implementation is available
        loadXML : function() {
        },

        _computeJsonDiff : function(diff_level){
            var dest = {};
            dest._class = this.className;
            if(this.jsonModel.hasOwnProperty("name")){
                dest.name = this.jsonModel.name;
            }
            var changeFound = false;
            var initialJson = this._xfa()._xfaTemplateCache.getInitialFormDomRef(this.htmlId);
            if(!initialJson)
                initialJson = this._xfa()._xfaTemplateCache.getInitialFormDomRef(this._templateId()) || {};
            var initialPropLength = _.filter(initialJson, function(value, key){
                return key !="extras";
            }, this).length;
            var jsonPropLength = _.filter(this.jsonModel, function(value, key){
                return key !="extras";
            }, this).length;

            if(jsonPropLength != initialPropLength){
                //We need to compare property sizes without 'extra' property since this is not actually part of schema
                changeFound = diff_level===0;   // only need _class and name during submission & restoreFormState
            }

            _.each(this.jsonModel, function(value, key){
                if(key === "_class" || key === "children" || key === "extras" || key == "{default}"){
                    return;
                }
                else {
                    //Note: We are assuming that any key that is present in templateJson would also be there in model json though it's value may be null/undefined
                    if(value !== initialJson[key]){
                        if(_.isArray(value)){
                            xfalib.runtime.xfa.Logger.error("xfa", "key:"+key + " has unexpected array value:"+JSON.stringify(value) + "parent:\n"+ JSON.stringify(src)) ;
                        }
                        else if(_.isObject(value)){
                            xfalib.runtime.xfa.Logger.error("xfa", "key:"+key + " has unexpected object value:"+JSON.stringify(value) + "parent:\n"+ JSON.stringify(src)) ;
                        }
                        else{
                            if (diff_level===0) {   // only need _class and name during submission & restoreFormState, rest will stripped by computeJsonDIff-s
                                dest[key] = value;
                                changeFound = true;
                            }
                        }
                    }
                }
            }, this);

            //we are sending additional properties like access and presence for diff_level 3 as a temp fix for customer
            if (diff_level === 1 || (window.FD && window.FD.isToggleEnabled("FT_FORMS-20493") && diff_level === 3)) {
                if (this._xfa()._templateSchema.hasAttribute(this.className, 'access') &&
                    _.contains(["exclGroup", "field", "subform"], this.className)) {
                    dest.access = this.jsonModel.access;
                    changeFound = true;
                }
                if (this._xfa()._templateSchema.hasAttribute(this.className, 'presence') &&
                    _.contains(["exclGroup", "field", "items", "subform", "draw"], this.className)) {
                    dest.presence = this.jsonModel.presence;
                    changeFound = true;
                }
            }
            return {"changed" : changeFound,
                jsonDifference : dest
            };
        },

        _getSomExpression : function() {
            if (this.mParent == null)
                return "xfa[0]." + this._escapeQualifiedName();
            else
                return this.mParent.somExpression + "." + this._escapeQualifiedName();
        },

        _escapeQualifiedName : function() {
            var name = "#" + this.className,
                index = this.mnClassIndex,
                objName = this.getAttribute("name")
            if (objName.length > 0) {
                name = objName;
                index = this.index;
            }
            var qname = name + "[" + index + "]";
            return qname.replace(/\./, "\\.");
        },

        _xfa : function() {
            return xfalib.script.Xfa.Instance;
        },

        _resetData: function() {

        },

        /**
         * Evaluates the specified SOM expression, beginning with the current XML form
         * object model object, and returns the value of the object specified in the SOM
         * expression
         *
         * @function
         */
        resolveNode : function() {
            var nodes = null;
            if (arguments.length == 1)
                nodes = this._resolveNodesCommon(this, arguments[0], false, true);
            else
                nodes = this._resolveNodesCommon(arguments[0], arguments[1], false,
                    true);

            if (nodes && nodes.length > 0)
                return nodes.item(0);
            else {

                //xfa.Logger.debug("resolveNode for somExpression " + arguments[1]
                //    + " failed");
                return null;
            }
        },

        /**
         * Evaluates the specified SOM expression, beginning with the current XML form
         * object model object, and returns the value of the object specified in the SOM
         * expression
         *
         * @function
         */
        resolveNodes : function() {
            var nodes = null;
            if (arguments.length == 1)
                nodes = this._resolveNodesCommon(this, arguments[0], true, true);
            else
                nodes = this._resolveNodesCommon(arguments[0], arguments[1], true, true);
            return nodes;
        },

        _objInList: function(obj) {
            var list = new xfalib.script.XfaList();
            list._append(obj);
            return list;
        },

        _findProperty: function(oSom) {
            var arr = new xfalib.script.XfaList();
          if(oSom.index == 0) {
              //check whether som is a dynamic property
              if(this.resolveProperties && this.resolveProperties.indexOf(oSom.name) != -1)
                arr._append(this[oSom.name])
          }
          return arr;
        },

        _resolveNodesCommon : function(obj, sSomExpression, bMultiple, bFirst) {
            var arr1 = xfalib.script.SOMExpression.prototype.splitExpression(sSomExpression);
            if(arr1[0] == '$') {
                arr1.splice(0,1,this.somExpression);
                sSomExpression = arr1.join(".");
            }
            if(arr1[0].charAt(0) == '$' || arr1[0] == 'xfa' || arr1[0] == 'this') {
                var root, i = arr1[0].length + 1;
                switch(arr1[0]) {
                    case "xfa":
                    case "$xfa":
                        root = this._xfa();
                        break;
                    case "$template":
                        root = this._xfa().template
                        break;
                    case "$form":
                        root = this._xfa().form;
                        break;
                    case "this":
                        root = this._xfa()._contextNode();
                        break;
                }
                if(arr1.length == 1)
                    return this._objInList(root)
                return this._resolveNodesCommon(root,sSomExpression
                    .substr(i), bMultiple, bFirst);
            }

            var nCurrentIndex = 0;
            // TODO: Do contextNode mumbo jumbo
            if (this._xfa() && (this._xfa()._contextNode() != null))
                nCurrentIndex = this._xfa()._contextNode().index;

            var oChildren = null; // returned as either an array of single object
            var oParent = obj;
            var si = 0;
            var bRootMatch = false;

            //
            // See if the first token of the expression matches this node
            // On the first call the children are checked first
            //
            var oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[0], obj.index);
            if ((bFirst == false) && (oSOM.equals(obj) || (oSOM.scalerMatch == obj))) {
                bRootMatch = true;
                //
                // found
                //
                if ((arr1.length == 1)) {
                    //
                    // If the expression only has one token then the expression matches
                    // this node
                    //
                    if (!bMultiple) {
                        var list = new xfalib.script.XfaList();
                        list._append(obj);
                        return list;
                    }

                    oParent = obj.parent;
                    if (oParent == null) {
                        oChildren = new xfalib.script.XfaList();
                        oChildren._append(obj);
                        return oChildren;
                    }
                    si = 0;
                } else {
                    //
                    // If the expression has more than one token then start looking for
                    // a match of subsequent tokens with the children of this node.
                    //
                    si = 1;
                    oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[1], 0);
                }
            } else {
                //
                // Check for match with one of the child nodes
                //
                oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[0], nCurrentIndex);
            }

            if (obj._isContainerNode()) {
                var bElipsis = false;

                for ( var j = si; j < arr1.length; j++) {
                    if (arr1[j] == "..") {
                        bElipsis = true;
                        j++;
                        if (j == arr1.length)
                            break;
                        oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[j], 0);
                    }

                    var bLast = ((j + 1) == arr1.length);
                    oChildren = new xfalib.script.XfaList();

                    if (!(oParent instanceof xfalib.script.XfaList)) {
                        var oParentList = new xfalib.script.XfaList();
                        oParentList._append(oParent);
                        oParent = oParentList;
                    }

                    for ( var k = 0; k < oParent.length; k++) {
                        var children,
                            parent = oParent.item(k);
                        if(parent != null && parent._isContainerNode()) {
                            if (bElipsis) {
                                children = parent._findChildrenDeep(oSOM,
                                    bMultiple);
                                bElipsis = false;
                            } else {
                                children = parent._findChildren(oSOM, bMultiple);
                                if(children.length == 0) {
                                    children = parent._findProperty(oSOM);
                                }
                            }
                        }

                        oChildren._concat(children);
                    }

                    if (oChildren.length == 0) {
                        break;
                    }

                    bRootMatch = true;
                    if (bLast == false) {
                        oSOM = xfalib.script.XfaModelRegistry.prototype.createSomExpression(arr1[j + 1], 0);
                        oParent = oChildren;
                    }
                }
            }

            if (oChildren && (oChildren.length != 0)) {
                return oChildren;
            }

            if ((bRootMatch == true) || (obj.parent == null)) {
                if (bFirst == true) {
                    //
                    // Try again attempting to match the current node
                    //
                    return this._resolveNodesCommon(obj, sSomExpression, bMultiple,
                        false);
                }
                if (obj.parent != null)
                    return this._resolveNodesCommon(obj.parent, sSomExpression,
                        bMultiple, false);

                if (bMultiple)
                    return new xfalib.script.XfaList();

                return null;
            } else {
                //
                // try parent
                return this._resolveNodesCommon(obj.parent, sSomExpression, bMultiple,
                    false);
            }
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a container
         *          Node or not
         */
        _isContainerNode : function() {
            return false;
        },

        _isXFAContainerNode : function() {
            return false;
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a Field or not
         */
        _isField : function() {
            return false;
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a subform or
         *          not
         */
        _isSubform : function() {
            return false;
        },

        _isExclusionGroup : function() {
            return false;
        },

        _findChildren : function(oSOM, bMultiple) {
            return null;
        },

        _findChildrenDeep : function(oSOM, bMultiple) {
            return null;
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a content Node
         *          or not
         */
        _isContent : function() {
            return false;
        },

        _isEventNode : function(){
            return false;
        },

        clone : function() {
            var clonedJson = {};
            this.copyObject(this.jsonModel, clonedJson,{exceptions : ["htmlId"]} );
            var node = xfalib.script.XfaModelRegistry.prototype.createModel(clonedJson);
            return node;
        },

        nakedFieldReferences : function(nIndex, createGetterSetter,obj) {
            return;
        },

        getAttribute: function(name, bPeek) {
            var attrValue = undefined;
            //Bug#3609434 : check only for undefined
            if(name && !_.isUndefined(this.jsonModel[name])) {
                attrValue = this.jsonModel[name];
            }
            else if(bPeek !== false) {
                attrValue = this._getDefaultAttribute(name);
            } else {
                return null;
            }
            if(name == "name" && (_.isUndefined(attrValue) || _.isNull(attrValue))){
                /* LC-8150: If attrName is name and attrValue is undefined or null then we return empty string instead of null.
                * Reason being most of the code assume that every node would have name property
                * */
                attrValue = "";
            }
            return attrValue;
        },

        /*
         * conditions for putting a node in global context
         * 1. It should have a name
         * 2. Its index should match with the index provided
         *                  OR
         * 2. There should not be more than one node with the same name in its normalizedParent Bug#3594282
         */
        getNaked : function(nIndex,createGetterSetter,Obj,scope) {
            var nodeName = this.getOrElse(this.jsonModel, "name", "");
            if ((nodeName != null) && (nodeName.length != 0) && ((scope && scope.moNameArray[nodeName] == 1) || (nIndex == this.index))) {
                //TODO: keep a state whether this node was previously naked or not. If yes do nothing
                var oObject = document[nodeName];
                if ((oObject == null) || (oObject instanceof xfalib.script.Node)) {
                    if(createGetterSetter ){
                        if(Obj._private["_"+nodeName+"_"]==null || Obj._private["_"+nodeName+"_"]==undefined){
                            this._createGetterSetter(Obj, nodeName, this);
                        }
                    }
                    else
                        Obj["_"+nodeName+"_"] = Obj["_"+nodeName+"_"] || this;
                }
            }
        },

        _getNakedThis : function(){
            return this;
        },

        toJSONString : function() {
            return JSON.stringify(this.jsonModel);
        },

        /**
         * @private
         *
         * this function performs initialization for this node.
         */
        _initialize : function() {

        },

        /**
         * @private
         * @function indicate that this is a Form node (~~).
         */
        _isForm : function() {
            return false;
        },

        _destroy : function(oChild) {
            var evnt = xfalib.script.XfaModelEvent.createEvent( xfalib.script.XfaModelEvent.OBJECT_DESTROYED, this,
                'destroy', null, this);
            this.trigger(evnt.name,evnt);
            this.off();
            var prop =  "_"+this.getAttribute("name")+"_";
            if (xfalib.runtime.hasOwnProperty(prop) && typeof xfalib.runtime[prop] != "undefined")
                if (xfalib.runtime[prop].somExpression == this.somExpression)
                    xfalib.runtime[prop] = undefined;
            this._xfa()._xfaTemplateCache.removeModel(this.htmlId);
        },

        _matches : function(oNode) {
            return (oNode != null && this.somExpression == oNode.somExpression);
        },

        _setFocus : function() {
            var evnt = xfalib.script.XfaModelEvent.createEvent( xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'focus', null, this);
            this.trigger(evnt.name,evnt);
        },

        _templateRef : function(){
            return this._xfa()._xfaTemplateCache.getTemplateRef(this.getOrElse(this.jsonModel, "extras.htmlId", null));
        },

        _templateId : function(){
            return this.getOrElse(this._templateRef(), "extras.htmlId", null);
        },

        _createGetterSetter : function(container,name,obj) {
            var iName = "_" + name + "_";
            if(!container.hasOwnProperty(name)){
                Object.defineProperty(container,name,{
                    get: function() {
                        if(this._private[iName]) {
                            return this._private[iName]._getNakedThis();
                        }
                        return undefined;
                    },
                    set : function(val) {
                        var obj = this._private[iName];
                        obj[obj._default] = val;
                    }
                });
            }
            container._private[iName]=obj;
        },

        _getDefaultAttribute : function(attribute) {
            return this._xfa()._templateSchema.getDefaultAttribute(this.className, attribute);
        },

        _getDefaultElement : function(elName, index, append) {
            var relation = this._xfa()._templateSchema._getRelation(this.className, elName);
            if(relation == xfalib.template.Constants.zeroOrOne || relation == xfalib.template.Constants.oneOfChild ||
                ((relation == xfalib.template.Constants.zeroOrTwo || relation == xfalib.template.Constants.zeroOrFour) && index == 0)){
                var defaultEl = xfalib.script.XfaModelRegistry.prototype.createModel({_class : elName});
                if(defaultEl && append){
                    this._addChild(defaultEl._getNakedThis());
                }
                return defaultEl;
            }
            else
                return null;
        },

        _getDataType: function(attribute) {
            return this._xfa()._templateSchema._getDataType(this.className, attribute);
        },

        _getRelation: function(child) {
            return  this._xfa()._templateSchema._getRelation(this.className,child.className);
        },

        //this function filters the nodes based on a filterFn.
        //this processes not only immediate children but goes recursively through the whole tree
        _filterNodes:function(filterFn) {
            var nodeList = new xfalib.script.XfaList();
            if (this._isContainerNode()) {
                var children = this._getChildren();
                for(var i=0; i< children.length; i++){
                    var n = children.item(i);
                    if(filterFn(n))
                        nodeList._append(n);
                    nodeList._concat(n._filterNodes(filterFn));
                }
            }
            return nodeList;
        },

        getElement: function(className,index, bPeek) {
            index = index || 0;
            var arr = this._findChildren(xfalib.script.XfaModelRegistry.prototype.createSomExpression(className+"["+index+"]"),false);
            if(arr && arr.length >0)
                return arr.item(0);
            else if(!bPeek && (this._getOneOfChild &&  !this._getOneOfChild(true)))
                return this._getDefaultElement(className, index, true);
            else
                return null;
        },

        setElement: function(element, className,index){
            if(_.isNumber(element) || _.isBoolean(element) || _.isDate(element) || _.isString(element)){
                var childNode = this.getElement(className, index);
                if(childNode && childNode._default){
                    childNode[childNode._default] = element;
                }
            }
            return null;
        },

        setAttribute: function(value, attrName){
            this.jsonModel[attrName] = this.validateInput(value, this._getDataType(attrName),this.jsonModel[attrName]);
        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap : function(map) {
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * @param map
         * @private
         */
        _restoreDataSomMap : function (map) {

        },

        _playDataXML: function(xmlDocument, contextNode) {

        },

        generateDataXML: function(rootNode, contextNode) {

        }

    });

    Node.defineProps({
        "parent" : {
            get : function() {
                return this.mParent;
            },
            set : function(parent) {
                parent = this.validateInput(parent, "object",null);
                this.mParent = parent;
            },
            resolve:true
        },

        "name"  : {
            get : function() {
                return this.getAttribute("name");
            },
            set : function(sName) {
                //sName = this.validateInput(sName, "string");
                //this.jsonModel.name = sName;
            },
            configurable:true
        },

        "nodes" : {
            get : function() {
                if (this._isContainerNode()) {
                    return this._getChildren();
                }
                return new xfalib.script.XfaList();
            }
        },

        "index" : {
            get : function() {
                return this.mnIndex;
            },
            set : function(nIndex) {
                nIndex = this.validateInput(nIndex, "integer",this.mnIndex);
                this.mnIndex = nIndex;
            }
        },

        "somExpression" : {
            get : function() {
                return this._getSomExpression();
            },
            set : function() {
                xfalib.runtime.xfa.Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-006"],["setting SomExpression"])
                throw "unsupported operation";
            }
        },

        "isContainer" : {
            get : function() {
                return this._isXFAContainerNode();
            }
        },

        "htmlId" : {
            get : function(){
                return this.getOrElse(this.jsonModel, "extras.htmlId", null);
            },
            set : function(sHtmlId){
                this.jsonModel.extras = this.jsonModel.extras || {};
                this.jsonModel.extras.htmlId = sHtmlId;
            }
        },

        "isNull" : {
            get : function(){
                return false;
            }
        },

        "all" : {
            get : function(){
                var list = new xfalib.script.XfaList();
                var som = xfalib.script.XfaModelRegistry.prototype.createSomExpression(this.jsonModel.name+"[*]");
                try {
                    if(this.jsonModel.name)  {
                        if(this.parent)
                            return this.parent._findChildrenDeep(som, true);
                        else return list;
                    }
                    else throw "Name undefined" ;
                }
                catch(e)   {
                    console.error("Get operation all requires the node to have a name");
                }


            }
        },

        "extras" :{
            get: function() {
                return this.getElement("extras",0)
            }
        }

    });
})(_, xfalib);


/**
 * @package xfalib.script.Element
 * @import xfalib.script.Node
 * @fileOverview The file creates the Element Class required for XFA
 *               library
 * @version 0.0.2
 */

(function (_, xfalib) {
    /**
     * @class The class represents all the XFA Objects which can contain other XFA
     *        nodes inside them
     * @extends com.adobe.xfa.scripting.Node
     *
     * @property {Array} children children of the Element
     *
     * @constructor
     * @param {string}
     *            name the name of the node
     *
     * @type {*|void}
     */
    var Element = xfalib.script.Element = xfalib.script.Node.extend({

        initialize: function () {
            Element._super.initialize.call(this);
            this._moChildNodes = [];
            this.mnCurrentIndex = -1;
            this.moNameArray = new Object();
            this.moNormalizedChildren = new Array();
            this._private = {};
            this._initChildren();
        },

        _initChildren: function () {
            var children = new Array();
            var lastCreatedInstanceManager = null;

            if (this.jsonModel.children) {
                var j = 0;
                for (var i = 0; i < this.jsonModel.children.length; i++) {
                    var child = this.jsonModel.children[i];
                    var childModel = xfalib.script.XfaModelRegistry.prototype.createModel(child);
                    if (childModel instanceof xfalib.script.InstanceManager) {
                        lastCreatedInstanceManager = childModel;
                    }
                    else if (childModel instanceof xfalib.script.Subform) {
                        if (lastCreatedInstanceManager != null) {
                            if (lastCreatedInstanceManager.name.length == 0)
                                lastCreatedInstanceManager.name = "_" + childModel.name;
                            lastCreatedInstanceManager._manageChild(childModel);
                        }
                    }
                    if (childModel) {
                        children[j++] = childModel;
                    }
                }
                this.children = children;
            }
        },

        _getChildren: function (child) {
            var parent = this;
            var obj = {"parent": parent};
            var list = new xfalib.script.XfaList(obj);
            for (var i = 0; i < this.moChildNodes.length; i++) {
                list._append(this.moChildNodes[i]._getNakedThis());
            }
            return list;
        },

        /**
         * The functions adds a child to this containerNode
         *
         * @function
         * @param {node}
         *            child The child node to add to this Element
         *
         */
        _addChild: function (child) {
            if (child != null) {
                this._addChildAt(child, this.moChildNodes.length);
            }
        },

        /**
         * @private
         * @function returns true if this is a scopeless container
         *
         */
        scopeless: function () {
            return false;
        },

        //includeDomElement tells whether DOMElement should be escalated to their parent
        appendNormalizedChildren: function (oNormalizedChildren, includeDomElement) {
            var i = 0;
            for (i = 0; i < this.moChildNodes.length; i++) {
                var oChild = this.moChildNodes[i];
                if (oChild != null) {
                    //CQ-102341 : border child of unnamed subform was getting appended to parent subform
                    if(includeDomElement === true || !(oChild instanceof xfalib.script.dom.Border)) {
                        oNormalizedChildren.push(oChild);
                    }
                    var oContainer = oChild;
                    if (oContainer
                        && (oContainer._isContainerNode() && oContainer.scopeless())) {
                        oContainer.appendNormalizedChildren(oNormalizedChildren, false);
                    }
                }
            }
        },

        /**
         * @private
         *
         * adds a dynamic property to this container.
         *
         * @param sName
         *            the name of the property to be added.
         * @param oValueObject
         *            the value of the property that is added.
         * @return the 0 based index of the property name.
         */
        _addProperty: function (sName, oValueObject, createGetterSetter) {
            var nIndex = 0;
            if ((sName != null) && (sName.length > 0)) {
                if (oValueObject == null) {
                    //
                    // just reset it
                    //
                    if (this[sName])
                        this[sName] = null;
                    this.moNameArray[sName] = 0;
                } else {
                    //
                    // add it as a property also keep track of the index
                    //
                    this.moNameArray[sName] = this.moNameArray[sName] || nIndex;
                    nIndex = this.moNameArray[sName]++;
                    if (nIndex == 0 && createGetterSetter) {
                        //
                        // Only put the first instance as a property of the container
                        // don't overwrite non dynamic properties
                        //
                        this._createGetterSetter(this, sName, oValueObject);
                    }
                }
            }
            return nIndex;
        },

        normalizeChildren: function () {
            this.moNormalizedChildren = new Array();
            this.appendNormalizedChildren(this.moNormalizedChildren, true);
            var bScopeless = this.scopeless();

            if (bScopeless) {
                //
                // must scope children in the parent container
                //
                var oParent = this.parent;
                if (oParent != null)
                    oParent.normalizeChildren();
            }

            var i = 0;
            this.moNameArray = new Object();
            for (; i < this.moNormalizedChildren.length; i++) {
                var oChild = this.moNormalizedChildren[i];
                //
                // Set properties and indices based on normalized children
                //
                var createGetterSetter = this._requireGetterSetter(oChild);
                var index = this._addProperty(this.getOrElse(oChild.jsonModel, "name", ""), oChild, createGetterSetter);
                var classIndex = this._addProperty('#' + oChild.className, oChild, false);
                if (!bScopeless) {
                    //
                    // scope indexes relative to this container
                    //
                    oChild.index = index;
                    oChild.mnClassIndex = classIndex;
                }
            }
        },

        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a container
         *          Node or not
         */
        _isContainerNode: function () {
            return true;
        },

        _requireGetterSetter: function (oChild) {
            //Tests whether dynamic getter/setter should be generated for this child which happens for infinite cardinality
            var relation = this._getRelation(oChild);
            return (relation == null || relation.max == Infinity);
        },

        _findChildren: function (oSOM, bMultiple) {
            var arr = new xfalib.script.XfaList();
            var elemFound = false;
            for (var j = 0; j < this.moNormalizedChildren.length; j++) {
                var oChild = this.moNormalizedChildren[j];
                var relation = this._getRelation(oChild);
                if (oSOM.equals(oChild) || (relation && relation.max != Infinity && oSOM.tagEquals(oChild))) {
                    arr._append(oChild._getNakedThis());
                    elemFound = true;
                }
                if (elemFound && !bMultiple)
                    return arr;
                else if (elemFound && oSOM.index != '*')
                    break;
            }

            if (oSOM.scalerMatch != null) {
                if (bMultiple == false) {
                    arr._append(oSOM.scalerMatch._getNakedThis());
                    return arr;
                }
                else {
                    // arr = [];
                    // arr.length = oSOM.scalarMatch;
                }
            }

            return arr;
        },

        /**
         * @private
         *
         * like _findChildren but searches deep for a match
         */
        _findChildrenDeep: function (oSOM, bMultiple) {
            var oObject = this._findChildren(oSOM, bMultiple);
            if (oObject == null || oObject.length == 0) {
                var oChildren = this.children;
                for (var j = 0; j < oChildren.length; j++) {
                    oObject = oChildren[j]._findChildrenDeep(oSOM, bMultiple);
                    if (oObject && oObject.length > 0)
                        break;
                }
            }
            return oObject;
        },

        /**
         * @private
         *
         * get the index of the specified child.
         *
         * @param {com.adobe.xfa.scripting.Node}
         *            oNode the node of which the index is to be found.
         * @return {number} the 0 based index of the node or -1 if not found.
         */
        _getChildIndex: function (oNode) {
            return this.moChildNodes.indexOf(oNode);
        },

        /**
         * @private
         *
         * add specified child to the specified index.
         *
         * @param oNode
         *            the node to be added.
         * @param nINdex
         *            the index where the child will be inserted.
         */
        _addChildAt: function (oNode, nIndex) {
            this.moChildNodes.splice(nIndex, 0, oNode);
            this.jsonModel.children = this.jsonModel.children || [];
            this.jsonModel.children.splice(nIndex, 0, oNode.jsonModel);
            oNode.parent = this;
            this.normalizeChildren();
            this._postAddChild(oNode);
        },

        _postAddChild: function (oNode) {
            oNode._initialize();
            if (oNode instanceof xfalib.script.DOMElement || oNode instanceof xfalib.script.GenericText) {
                oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED, this);
            }
        },

        _destroy: function (oChild) {
            for (var i = 0; i < this.moChildNodes.length; i++) {
                var child = this.moChildNodes[i];
                if (child != null)
                    child._destroy();
            }
            Element._super._destroy.call(this, oChild);
        },

        _removeAll: function () {
            _.each(this.moChildNodes, function (oChild, index) {
                oChild._destroy();
            });
            this.moChildNodes = [];
            this.jsonModel.children = [];
            this.normalizeChildren();
            //ToDo add event trigger like _remove method if required
        },

        _removeChild: function (oChild) {
            oChild._destroy();
            var nIndex = this.moChildNodes.indexOf(oChild);
            this.moChildNodes.splice(nIndex, 1);
            this.jsonModel.children.splice(nIndex, 1);
            this.normalizeChildren();
            this._postRemoveChild(oChild);
        },

        _postRemoveChild: function (oChild) {
            //do nothing here
        },

        /**
         * @private
         *
         * initialize this Container Node
         */
        _initialize: function () {
            if ((this.moChildNodes == null) || (this.moChildNodes.length == 0)) {
                this.mbInitialized = true;
                return;
            }

            if (this._xfa() == null) {
                throw (xfalib.locale.LogMessages["ALC-FRM-901-003"]);
            }

            // Init this
            if (this.parent == null) {
                this.index = 0;
                //this._xfa()._pushContextNode(this);
            }

            //
            // loop through the controls that are child components of this container
            // copy into array, since moChildNodes may be modified as we initialize
            // InstanceManagers
            //

            var oChildren = this.moChildNodes;
            for (var i = 0; i < oChildren.length; i++) {
                var oNode = oChildren[i];
                if (oNode == null)
                    xfalib.runtime.xfa.Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-004"], [this.getAttribute("name"), i]);
                else
                    oNode._initialize();
            }

            this.mbInitialized = true;

        },

        playJson: function (pJsonModel) {
            /*
             * playJson assumption: The non dom elements should always maintain the structural hierarchy.
             * For dom elements, we support only value and items. rest are ignored.
             */
            Element._super.playJson.call(this, pJsonModel);
            var schemaChildren = this._xfa()._templateSchema.getChildren(this.className);
            _.each(schemaChildren, function (schemaChildProps, schemaChildTag) {
                // if schemaChildTag is a DOMelem other than items,value continue
                if (xfalib.script.dom[schemaChildTag.charAt(0).toUpperCase() + schemaChildTag.substring(1)] !== undefined // TODO : take care of those domElements with 2nd order inheritance
                    && !_.contains(["value", "items"], schemaChildTag)) {
                    return;
                }
                if (this.playJsonForElement(schemaChildTag, pJsonModel)) {   // continue if this childTag has special handling
                    return;
                }

                var relation = schemaChildProps.relation;
                var newJChildren = _.filter(_.compact(pJsonModel.children), function (jChild) {
                    return jChild._class == schemaChildTag;
                }, this);
                var oldMChildren = _.filter(this.moChildNodes, function (mChild) {
                    return mChild.className == schemaChildTag;
                }, this);
                var oneOfChildProcessed = false;

                // to merge field items having bingdItems property
                // honour saveProperty while playingJson for new and old children
                // items have zeroOrTwo relation
                if (schemaChildTag == "items" && this.getElement("#bindItems") && oldMChildren.length && newJChildren.length) {
                    var childIndex = -1,
                        newChild = null,
                        oldChild = null;
                    childIndex = _.findIndex(oldMChildren , function (oldMChild) {
                        return this.getOrElse(oldMChild, "save", 0) == 1;
                    }, this);
                    oldChild = oldMChildren.splice(childIndex, 1);
                    childIndex = _.findIndex(newJChildren , function (newJChild) {
                        return this.getOrElse(newJChild, "save", 0) == 1;
                    }, this);
                    newChild = newJChildren.splice(childIndex, 1);
                    oldChild[0].playJson(newChild[0]);  // playJson for item having save property

                    oldChild = oldMChildren.shift();
                    newChild = newJChildren.shift();
                    if (oldChild && newChild) {
                        oldChild.playJson(newChild);  //playJson for item without save property
                    }
                }

                switch (relation) {
                    case xfalib.template.Constants.zeroOrOne :
                        if (newJChildren.length > 0 && oldMChildren.length == 0) { //Addition
                            var newMChild = xfalib.script.XfaModelRegistry.prototype.createModel(newJChildren[0]);
                            this._addChild(newMChild);
                        }
                        else if (newJChildren.length == 0 && oldMChildren.length > 0) { //removal
                            this._removeChild(oldMChildren[0]);
                        }
                        else if (newJChildren.length > 0 && oldMChildren.length > 0) {
                            oldMChildren[0].playJson(newJChildren[0]);
                        }
                        break;

                    case xfalib.template.Constants.oneOfChild :
                        if (!oneOfChildProcessed && newJChildren.length > 0 && oldMChildren.length > 0) {
                            // For the time being let's assume oneOfChild type can not be modified and can not be added/removed
                            oldMChildren[0].playJson(newJChildren[0]);
                            oneOfChildProcessed = true;
                        }
                        break;

                    default :
                        _.each(oldMChildren, function (oldMChild) {
                            var newJChild = newJChildren.shift();
                            if (newJChild) {
                                oldMChild.playJson(newJChild);
                            }
                            else {
                                this._removeChild(oldMChild);
                            }
                        }, this);
                        if (newJChildren.length > 0) {
                            _.each(newJChildren, function (newJChild) {
                                var newMChild = xfalib.script.XfaModelRegistry.prototype.createModel(newJChild);
                                this._addChild(newMChild);
                            }, this);
                        }
                        break;
                }
            }, this);
        },

        playJsonForElement: function (elName, pJsonModel) {
            return false;
        },


        _computeJsonDiff: function (diff_level) {
            if (diff_level===0 && this._newChild == true) {
                return {
                    "changed": true,
                    "jsonDifference": this.jsonModel
                };
            }
            var diff = Element._super._computeJsonDiff.call(this, diff_level);
            var attrChangeFound = diff.changed;
            var dest = diff.jsonDifference;
            var initialJson = this._xfa()._xfaTemplateCache.getInitialFormDomRef(this.htmlId);
            if (!initialJson) {
                initialJson = this._xfa()._xfaTemplateCache.getInitialFormDomRef(this._templateId()) || {};
            }
            var childChangeFound = false;
            var initialJsonChildren = this.getOrElse(initialJson, "children", []);
            if (this.getOrElse(this.moChildNodes, "length", 0) != this.getOrElse(initialJsonChildren, "length", 0)) {
                childChangeFound = true;
            }
            else {
                childChangeFound = (null != _.find(this.moChildNodes, function (mChild, index) {
                    if ((mChild.className != initialJsonChildren[index]._class) || (mChild.jsonModel.name !== initialJsonChildren[index].name)) {
                        return true;
                    }
                    return false;
                }, this));
            }

            var destChildren = [];
            _.each(this.moChildNodes, function (mChild, index) {
                var childDiff = mChild._computeJsonDiff(diff_level) || {};
                if (!(diff_level>0 && _.isEmpty(childDiff.jsonDifference))) {  // skip if during submission & restoreFormState the childDiff is empty
                    destChildren.push(childDiff.jsonDifference);
                    if (!childChangeFound && childDiff.changed) {
                        childChangeFound = true;
                    }
                }
            }, this);

            if (diff_level>0 && destChildren.length == 0) { // skip if during submission  & restoreFormState no children present
                if (this.jsonModel._class !== 'form') { // except for root subform LC-9317
                    dest = undefined; // must be careful while assigning to jsonDifference, ideally should let it be {}, but this costs bytes in final json
                }
            } else {
                dest.children = destChildren;
            }

            return {"changed": childChangeFound || attrChangeFound,
                jsonDifference: dest
            };
        },

        _getOneOfChild: function (bPeek) {
            try {
                bPeek = typeof bPeek === "undefined" ? false : true;
                if (!this._oneOfChild && bPeek === false) {
                    var children = this._xfa()._templateSchema._getOneOfChild(this.className);
                    this._oneOfChild = _.find(this.moChildNodes, function (child) {
                        return child.className in children;
                    });
                    if (this._oneOfChild)
                        this._oneOfChild = this._oneOfChild._getNakedThis();
                }
                return this._oneOfChild;
            } catch (exception) {
                this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-017"], [exception, "oneOfChild", contextObj.somExpression])
            }
        },

        /**
         * Return the bind child of the current element. getElement API doesn't return the correct value in case of
         * unnamed element inside the current element
         * @returns {*}
         * @private
         */
        _getBinding: function () {
            return _.find(this.moChildNodes, function(child) {
                return child.className === "bind"
            })
        },

        /**
         * Checks whether binding is none or not. Returns false if binding is set to none, otherwise false.
         * @returns {boolean}
         */
        hasDataBinding: function () {
            var bind = this._getBinding();
            //bind = null means use name binding
            return bind == null || bind.match !== "none";
        },

        /**
         * returns dataSom for the current field
         * @returns {*}
         * @private
         */
        _getDataSom: function () {
            return this.getOrElse(this, "extras.FS_EXTRAS.FS_DATA_SOM.value", null);
        },

        /**
         * Returns true if the bindRef for the element points to an attribute otherwise false.
         * @returns {boolean}
         * @private
         */
        _isBindRefAttribute: function () {
            return 1 == this.getOrElse(this, "extras.FS_EXTRAS.IS_ATTRIBUTE.value", 0);
        },

        _convertRefToXPath: function (bindRef) {
            var $regex = /^\$\./,
                $recordRegex = /^\$record\./,
                relative,
                _bindRef,
                somArray;
            if(bindRef.match($recordRegex) != null) {
                relative = false;
                _bindRef = bindRef.replace($recordRegex, "");
            } else {
                relative = true;
                _bindRef = bindRef.replace($regex, "");
            }
            somArray = xfalib.script.SOMExpression.prototype.splitExpression(_bindRef);
            _bindRef = _.reduce(somArray, function (memo, som, indx) {
                var currentSom = xfalib.script.XfaModelRegistry.prototype.createSomExpression(som, 0),
                    index = currentSom.index;
                // index in SOM Expression starts from 0 whereas in xpath it starts from 1
                if(_.isNumber(index)) {
                    index += 1;
                }
                if(indx === somArray.length - 1 && this._isBindRefAttribute()) {
                    // only last part in the bindRef can be attribute
                    return memo + "@" + currentSom.name;
                }
                return memo + currentSom.name + "[" + index + "]/"
            }, "", this);
            //replace the last / if exists with empty string
            _bindRef = _bindRef.replace(/\/$/,"");
            return {
                relative: relative,
                bindRef: _bindRef
            };
        },

        /**
         * Returns the xpath from the bind.dataref property. removes the leading $. from the dataRef.
         * TODO: in some places the dataRef property has $record. Need to discuss that case
         * Moreover this might not be needed if XTG provides DATASOM for the subforms.
         * @returns {*}
         * @private
         */
        _getXpathFromBindRef: function () {
            var bind = this._getBinding(),
                bindRef = this.getAttribute("name"),
                $regex = /^\$\./,
                $recordRegex = /^\$record\./,
                relative = true,
                somArray;
            if(bind != null) {
                if(bind.match === "dataRef") {
                    if(bind.ref.match($recordRegex) != null) {
                        relative = false;
                        bindRef = bind.ref.replace($recordRegex, "");
                    } else {
                        relative = true;
                        bindRef = bind.ref.replace($regex, "");
                    }
                    somArray = xfalib.script.SOMExpression.prototype.splitExpression(bindRef);
                    bindRef = _.reduce(somArray, function (memo, som, indx) {
                        var currentSom = xfalib.script.XfaModelRegistry.prototype.createSomExpression(som, 0),
                            index = currentSom.index;
                        // index in SOM Expression starts from 0 whereas in xpath it starts from 1
                        if(_.isNumber(index)) {
                                index += 1;
                        }
                        if(indx === somArray.length - 1 && this._isBindRefAttribute()) {
                            // only last part in the bindRef can be attribute
                            return memo + "@" + currentSom.name;
                        }
                        return memo + currentSom.name + "[" + index + "]/"
                    }, "", this);
                    //replace the last / if exists with empty string
                    bindRef = bindRef.replace(/\/$/,"");
                    return {
                        relative: relative,
                        bindRef: bindRef
                    };
                } else if (bind.match === "global" && ["field", "exclGroup"].indexOf(this.className) !== -1) {
                    return {
                        relative: "global",
                        bindRef: this.getAttribute("name") + "[1]"
                    };
                } else if(bind.match === "once") { // for fields with patterns
                    return this._getXPathForUseNameBinding();
                }
                // bind.match === null
                return null;
            }
            //use name binding
            /** for unnamed elements, with data binding as use name, we are returning null */
            return this._getXPathForUseNameBinding();
        },

        _getXPathForUseNameBinding: function () {
            var name = this.getAttribute("name"),
                //SOM Index starts from 0 while in XPath it starts from 1
                index = this.index + 1;
            return name === "" ? null
                               : {
                                    relative: true,
                                    bindRef: name + "[" + index + "]"
                                 };
        },

        /**
         * Iterate over every child and add entry for them into the dataSOMMap. See @ Node._getDataSomMap for more details
         * @param map
         * @private
         * if map is not an object it behaves as an identity function
         */
        _getDataSomMap: function(map) {
            if(!_.isObject(map)) {
                return map;
            }
            _.each(this.moChildNodes, function (child) {
                map = child._getDataSomMap(map);
            });
            return map;
        },

        /**
         * Iterate over every child and update their values based on the entries in the map. See @ Node._getDataSomMap
         * for more details
         * @param map
         * @private
         */
        _restoreDataSomMap: function (map) {
            if(!_.isObject(map)) {
                return;
            }
            _.each(this.moChildNodes, function (child) {
                child._restoreDataSomMap(map);
            })
        },

        /**
         * Evaluates the given xpath relative to contextNode or RootNode depending upon the value of xpath.relative
         * In case it is true, xpath is evaluates relative to contextNode otherwise rootNode
         * @param xpath
         * @param contextNode
         * @param rootNode
         * @returns {*}
         * @private
         */
        _getElementsFromXpath: function(xpath, contextNode, rootNode) {
            var nodeIter,
                XMLUtils = xfalib.ut.XMLUtils,
                doc = rootNode instanceof Document ? rootNode : rootNode.ownerDocument;
            if(xpath.relative === false) {
                nodeIter = XMLUtils.evaluateXPath(xpath.bindRef, rootNode, null,
                                    XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
            }
            else if(contextNode != null) {
                nodeIter = XMLUtils.evaluateXPath(xpath.bindRef, contextNode, null,
                                    XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
            }
            return nodeIter;
        },

        _playDataXML : function (xmlDocument, contextNode, currentBindRef) {
            _.each(this.children, function(child) {
               child._playDataXML(xmlDocument, contextNode, currentBindRef);
            }, this);
        },

        /**
         * Generates the XML by appending the elements in the rootNode
         * @param rootNode The rootNode of the xml. Generally the element that maps to the root of the form
         * @param contextNode Current Node where to insert the elements in case of relative bindings
         */
        generateDataXML: function (rootNode, contextNode) {
            _.each(this.moChildNodes, function(child) {
                child.generateDataXML(rootNode, contextNode);
            });
        },

        /**
         * Returns bindRef relative to parentBindRef. If bindRef is not a child of parentBindRef, returns null
         * otherwise removes the parentBindRef string from the bindRef
         * @param parentBindRef
         * @param bindRef
         * @returns {*}
         * @private
         */
        _getRelativeXPath: function(parentBindRef, bindRef) {
           var regexp = new RegExp("^" + parentBindRef+"/");
           if(bindRef.match(regexp)) {
              return bindRef.replace(regexp,"");
           }
           return null;
        }
    });

    Element.defineProps({
        "children": {
            get: function () {
                var nodes = [];
                for (var i = 0; i < this.moChildNodes.length; i++) {
                    var child = this.moChildNodes[i];
                    if (child != null)
                        nodes.push(child);
                }
                return nodes;
            },
            set: function (moChildren) {
                moChildren = this.validateInput(moChildren, "object", null);
                this.moChildNodes = new Array(moChildren.length);
                this.jsonModel.children = [];
                for (var i = 0; i < moChildren.length; i++) {
                    this.moChildNodes[i] = moChildren[i];
                    this.moChildNodes[i].parent = this;
                    this.jsonModel.children[i] = moChildren[i].jsonModel;
                }
                this.normalizeChildren();
            }
        },

        "oneOfChild": {
            get: function () {
                return this._getOneOfChild();
            }
        },

        moChildNodes: {
            get: function () {
                return this._moChildNodes;
            },
            set: function (value) {
                this._moChildNodes = value;
            }
        }

        /*"borderWidth" : {
         get : function() {
         this._borderWidth = this._borderWidth || "0.6624 px" ;
         return (this._borderWidth);
         },

         set : function(width) {
         //TODO: Set border.edge.presence property to visible once Border is implemented
         this._borderWidth = width ;
         var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
         this,"borderWidth",null,width);
         this.trigger(evnt.name,evnt);
         }
         },      */

    });

})(_, xfalib);


(function (_, xfalib) {
    var GenericText = xfalib.script.GenericText = xfalib.script.Node.extend({
        _default: "value",
        initialize: function () {
            GenericText._super.initialize.call(this);
            this._modelChanged = false;
        },

        setAttribute: function (value, attrName) {
            GenericText._super.setAttribute.call(this, value, attrName);
            this._modelChanged = true;
        },

        _computeJsonDiff: function (diff_level) {
            /*
             * Since we do not maintain initialJson or templateJson for DOM elements, we use this approximate method to compute jsonDiff.
             * This assumes that all attr changes would happen through setAttribute API.
             * seeAlso: DOMElement and NodeValue
             */
            // must pass 'this' node as argument array to computeDomJsonDiff
            return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level>0, xfalib.ut.XfaUtil.prototype.computeDomJsonDiff, [this]);
        }

    });

    GenericText.defineProps({
        "value": {
            get: function () {
                return this.jsonModel._value;
            },
            set: function (value) {
                if (value !== this.jsonModel._value) {
                    this._modelChanged = true;
                    var oldVal = this.jsonModel._value
                    this.jsonModel._value = this.validateInput(value, "string", this.jsonModel._value);
                    var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED, this, this.className, oldVal, this.jsonModel._value);
                    this.trigger(event.name, event);
                }
            }
        }
    });

})(_, xfalib);

(function (_, xfalib) {
    var DOMElement = xfalib.script.DOMElement = xfalib.script.Element.extend({
        _default: "value",
        initialize: function () {
            DOMElement._super.initialize.call(this);
            this._normalizePending = true;
            this._childrenInitializePending = true;
            this._childModified = false;
            this._modelChanged = false;
        },

        handleEvent: function (evnt) {
            if (evnt.name == xfalib.script.XfaModelEvent.DOM_CHANGED) {
                evnt._property = this.className + "." + evnt._property;
                this.trigger(evnt.name, evnt);
            }
        },

        _initChildren: function () {
        },

        _initialize: function () {
            //do nothing
        },

        _initChildrenInternal: function () {
            var children = new Array();
            var tempNameContainer = {};
            if (this.jsonModel.children) {
                var j = 0;
                for (var i = 0; i < this.jsonModel.children.length; i++) {
                    var child = this.jsonModel.children[i];
                    var childModel = xfalib.script.XfaModelRegistry.prototype.createModel(child);
                    children[j++] = childModel;
                    childModel.parent = this;
                    childModel.on(xfalib.script.XfaModelEvent.DOM_CHANGED, this);
                    childModel._initialize();
                    if (childModel.name) {
                        var nameIndex = tempNameContainer[childModel.name] || 0;
                        childModel.index = nameIndex;
                        nameIndex++;
                        tempNameContainer[childModel.name] = nameIndex;
                    }
                    if (childModel.className) {
                        var classIndex = tempNameContainer["#" + childModel.className] || 0;
                        childModel.mnClassIndex = classIndex;
                        classIndex++;
                        tempNameContainer["#" + childModel.className] = classIndex;
                    }
                }
                this._moChildNodes = children;
            }
        },

        _getNakedThis: function () {
            if (this._normalizePending) {
                this.normalizeChildren();
                this._normalizePending = false;
            }
            return DOMElement._super._getNakedThis.call(this);
        },

        setAttribute: function (value, attrName) {
            DOMElement._super.setAttribute.call(this, value, attrName);
            this._modelChanged = true;
        },

        _postAddChild: function (oNode) {
            DOMElement._super._postAddChild.call(this, oNode);
//            if(oNode instanceof xfalib.script.DOMElement)
            //        oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED,this) ;
            this._childModified = true;
            oNode._newChild = true;
        },

        _postRemoveChild: function (oChild) {
            DOMElement._super._postRemoveChild.call(this, oChild);
            this._childModified = true;
        },

        playJson: function (pJsonModel) {
            if (_.contains(["value", "items"], this.className)) {
                xfalib.script.Element.prototype.playJson.call(this, pJsonModel);
            }
        },

        _computeJsonDiff: function (diff_level) {
            if (diff_level && diff_level != 3) {
                return {
                    "changed": false,
                    "jsonDifference": {}
                };
            } else { // not called during submission
                if (this._newChild) {
                    return {
                        "changed": true,
                        'jsonDifference': this.jsonModel
                    };
                } else {
                    /*
                     * Since we do not maintain initialJson or templateJson for DOM elements, we use this approximate method to compute jsonDiff.
                     * This assumes that all attr changes would happen through setAttribute API.
                     * seeAlso: GenericText and NodeValue
                     */
                    var selfDiff = xfalib.ut.XfaUtil.prototype.computeDomJsonDiff.call(this, this, diff_level),
                        childrenDiff = [],
                        changed = selfDiff.changed || this._childModified,
                        childChanged = false,
                        jsonDifference = selfDiff.jsonDifference;

                    _.each(this.moChildNodes, function (mChild) {
                            var childDiff = mChild._computeJsonDiff(diff_level) || {};
                            childChanged = childChanged || childDiff.changed;
                            if (childDiff.changed && !_.isEmpty(childDiff.jsonDifference)) {
                                childrenDiff.push(childDiff.jsonDifference);
                            }
                        },
                        this);
                    if (this._childModified || childChanged) {
                        jsonDifference.children = childrenDiff;
                    }

                    return {
                        "changed": changed,
                        "jsonDifference": jsonDifference
                    };
                }
            }
        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap : function (map) {
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * @param map
         * @private
         */
        _restoreDataSomMap : function (map) {

        },

        _playDataXML: function (rootNode, contextNode) {

        },

        generateDataXML: function (xmlDocument, contextNode) {

        }

    });

    DOMElement.defineProps({
        moChildNodes: {
            get: function () {
                if (this._childrenInitializePending) {
                    this._initChildrenInternal();
                    this._childrenInitializePending = false;
                }
                return this._moChildNodes;
            },
            set: function (value) {
                this._moChildNodes = value;
            }
        }

    });

})(_, xfalib);



/**
 * @package xfalib.script.ContainerNode
 * @import xfalib.script.Element
 * @fileOverview The file creates the Container Element Class required for XFA
 *               library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * @class The class represents all the XFA Objects which can contain other XFA
     *        nodes inside them
     * @extends com.adobe.xfa.scripting.Element
     *
     * @property {Array} children children of the ContainerNode
     *
     * @constructor
     * @param {string}
        *            name the name of the node
     *
     */
    var ContainerNode = xfalib.script.ContainerNode = xfalib.script.Element.extend({
        _isXFAContainerNode : function() {
            return true;
        }

    });

})(_, xfalib);


(function(_,xfalib){
    var EventContainerNode = xfalib.script.EventContainerNode = xfalib.script.ContainerNode.extend({
        _defaults : {
            "access" : "open",
            "event" : {
                "type" : "click" //ideally, this should be activity
            },
            "validate" : {
                "disableAll" : "0",
                "formatTest" : "warning",
                "nullTest" : "disabled",
                "scriptTest" : "error",
                "message" : {
                    "defaultMessage" : {
                        value: xfalib.locale.Strings.validationIssue
                    }
                }
            }
        },

        initialize : function(){
            EventContainerNode._super.initialize.call(this);
            /**
             * @private
             * @type Object
             */
            this.moEvents = {};
            /**
             * marks the event that are fired in the current script execution as true.
             *
             * @private
             * @type Object
             */
            this.mActiveEvents = {};
            this._errorText = null;
            this._mFailedValTest = null;
            this._mFailedValLevel = null; //can be warning or error
            this.dependant = [];
            this.tests= null; //must be overridden by sub classes
            /**
             * @private
             * @type string
             */
            this.mEffectiveAccess = null;
            this.mEffectivePresence = null;
            //Initialize events array
            this._addEvents();
            this._eventListener();

            this._moContext = null;  // will cache the nakedReferences for each EventContainerNode
         },

        // visit this and all child nodes recursively
        _visitAllmoChildren: function (visitor) {
            if (_.isFunction(visitor)) {
                visitor(this);
            }

            _.each(this.moChildNodes, function (child) {
                if (_.isFunction(child._visitAllmoChildren)) {
                    child._visitAllmoChildren(visitor);
                }
            });
        },


        _eventListener :function() {
            for ( var i = 0; i < this.moChildNodes.length; ++i) {
               var oNode = this.moChildNodes[i];
               if(oNode instanceof xfalib.script.DOMElement)
                  oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED,this) ;
             }
        },

        /**
         * @private
         * @function
         * @param predicateTest : function containing predicate test.
         * @param execEvent : function containing events which needs to be executed.
         * executes events on child nodes provided as execEvent.
         */
        _execEventOnChildNodes : function (childNodesFilter, execEvent) {
            if(!this._isField()){ //Ideally isField check should not be here but a short cut for now since it's the only excption.
                _.each (this.moChildNodes, function(oNode) {
                    if (childNodesFilter(oNode)) {
                        execEvent(oNode);
                    }
                });
            }
        },

        _childNodesFilter : function (oNode) {
            return oNode._isEventNode() && oNode.className != "pageSet" && oNode.presence != "inactive";
        },

        execInitialize : function () {
            function execEvent (oNode) {
                oNode.execInitialize()
            };
            this._execEventOnChildNodes(this._childNodesFilter, execEvent);
            this.execEvent("initialize");
        },

        execFormReady : function() {
            function execEvent (oNode) {
                oNode.execFormReady()
            };
            this._execEventOnChildNodes(this._childNodesFilter, execEvent);
            this.execEvent("$formready");
        },

        execLayoutReady : function() {
            function execEvent (oNode) {
                oNode.execLayoutReady()
            };
            this._execEventOnChildNodes(this._childNodesFilter, execEvent);
            this.execEvent("$layoutready");
        },

        execCalculate : function() {
            function childNodesFilter (oNode) {
                return oNode._isEventNode() && oNode.presence != "inactive";
            };
            function execEvent (oNode) {
                oNode.execCalculate()
            };
            if (!this._xfa().host.calculationsEnabled)
                return true;
            else {
                this._execEventOnChildNodes(childNodesFilter, execEvent);
            }
           this.execEvent("calculate");
        },

        execValidate : function() {
            if (!this._xfa().host.validationsEnabled)
                return true;
            var valid = true;
            if(!this._isField()){
                for ( var i = 0; i < this.moChildNodes.length; ++i) {
                    var oNode = this.moChildNodes[i];
                    if (oNode._isEventNode()){
                        if(!oNode.execValidate())
                            valid = false;
                    }
                }
            }
            valid = valid && this._validate([]);
            return valid;
        },

        execPreSubmit : function () {
            var isSubmissionAllowed = true;  // to handle the cancelAction property, which if true will prevent submission
            if(!this._isField()) {
                _.each (this.moChildNodes, function(oNode) {
                    if (oNode._isEventNode() && oNode.presence != "inactive") {
                        isSubmissionAllowed = oNode.execPreSubmit() && isSubmissionAllowed;
                    }
                });
            }
            if (this.execEvent("$formpreSubmit") == false) {
                isSubmissionAllowed = false;
            }
            return isSubmissionAllowed;
        },

        /**
         *
         * creates a scope so that all the nodes accessible from this node
         * are available to the script event and returns the previous scope
         *
         * After executing the script the scope must be reset using _resetNakedReferencesScope
         * Not doing that will result in unstable state and cause serious issues
         *
         * @private
         * @function
         */
        _createNakedReferencesScope : function() {
            var startNode = this,
                currentIndex = this.index,
                oldContext = {};

            //store the old context in order to reset it.
            _.extend(oldContext,xfalib.runtime._private);

            //TODO: optimize to check with lastNakedSubform
            if (this._moContext == null) {
                xfalib.runtime._private = {};
                while (startNode) {
                    startNode.nakedFieldReferences(currentIndex, true, xfalib.runtime);
                    currentIndex = startNode.index;
                    startNode = startNode.parent;
                }
                this._moContext = xfalib.runtime._private;    // just copy ref as we are recreating xfalib.runtime._private
            } else {
                xfalib.runtime._private = this._moContext;
            }
            return oldContext;
        },

        /**
         *
         * The function should be called after executing the script to reset the scope
         * Not doing that will result in unstable state and cause serious issues
         *
         * @private
         * @function
         */
        _resetNakedReferencesScope : function(scope) {
            xfalib.runtime._private = {};
            _.extend(xfalib.runtime._private, scope);
        },

        /**
         * @private
         * @function
         * @param {string} eventName captures the event and sends it to the {@link _eventHandler}
         */
        execEvent : function(eventName, detail) {
            if(typeof this.moEvents[eventName] === "undefined") {
                if(this._xfa().moContextNodes.length == 0) {
                    this._xfa().runCalcAndValidate();
                }
                return true;
            }
            xfalib.runtime.xfa.Logger.debug("xfa", eventName+" fired for "+this.somExpression);
            //use standard event names instead of our home made names to match what pdf returns to user
            var stdEventName = this.xfaUtil()._xtgEventName[eventName] ? this.xfaUtil()._xtgEventName[eventName] : eventName;
            switch(eventName){
                case "change":
                    if (detail===undefined)
                        var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this}});
                    else
                        var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this,
                            "prevText":detail.prevText,"newText":detail.newText,"keyDown":detail.keyDown,
                            "modifier":detail.modifier,"shift":detail.shift,"change":detail.change,"fullText":detail.fullText}});
                    break;
                case "click":
                    if (detail===undefined)
                        var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this}});
                    else
                        var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this,"modifier":detail.modifier,"shift":detail.shift}});
                    break;
                default:
                    var $event = new xfalib.script.XfaModelEvent({"jsonModel":{"name":stdEventName,"target":this}});

            }
            xfalib.runtime.$event = $event;
            this._xfa().event = $event;
            xfalib.runtime.event = xfalib.acrobat.AcroEvent.cloneEvent($event);
            if(this.access == "protected" && eventName!=="calculate" && eventName!== "validate") {
                return;
            }
            // According to xfa spec : when a container is inactive any calculations, validations, or events it would normally generate are suppressed
            if (this.mEffectivePresence == "inactive") {
                return;
            }

            if (this.mActiveEvents[eventName]) {
                return;
            }
            this.mActiveEvents[eventName] = true;
            this._xfa()._pushContextNode(this);
            this._xfa().moContextScriptEvent = eventName;

            var oldScope = this._createNakedReferencesScope();

            var temp$ = $;
            $ = this;
            var rValue = this._eventHandler(eventName);
            $ = temp$;
            this.mActiveEvents[eventName] = false;
            this._xfa()._popContextNode();
            this._xfa().moContextScriptEvent = null;

            $event = null;
            if(this._xfa().moContextNodes.length == 0) {
                this._xfa().runCalcAndValidate();
            } else {
                this._resetNakedReferencesScope(oldScope);
            }
            return rValue;
        },

        handleDomEvent: function(evnt) {
            this.trigger(evnt.name,evnt);
        },

        handleEvent : function(event) {
            switch (event.name) {
                case xfalib.script.XfaModelEvent.OBJECT_DESTROYED:
                    return this.removeDependant(event.target);
                case xfalib.script.XfaModelEvent.DOM_CHANGED:
                      this.handleDomEvent(event)
                default:
                    //xfa.Logger.debug("event " + event.name + " not supported");
                    return false;
            }
        },

        addDependant: function(oNode) {
            if(!~this.dependant.indexOf(oNode) && oNode != this)
                this.dependant.push(oNode);
        },

        _addEvents : function() {
            var events = _.filter(this.moChildNodes, function(childModel){
               return childModel.className == "event";
            });
            if (events && events.length > 0) {
                for ( var i = 0; i < events.length; i++) {
                    var event = events[i];
                    // ref was added to support formReady and layoutReady where the event names are available as
                    //$formReady and $layoutReady (check - _xtgEventName in the class: XfaUtil.js).
                    // When we add a style to an element, designer adds a ref value of '$'
                    //which is also the default. In such a scenario the event names become $click, $change, etc. To
                    //handle this for now (without a full implementation of ref) we are removing the $ default value
                    //and setting it as $click -> click, etc. For details on ref:
                    //http://blogs.adobe.com/formfeed/2009/03/xfa_30_event_propagation.html
                    var ref = (event.ref || "");
                    if(ref == "$") ref = "";
                    var type = ref + event.activity;
                    this.moEvents[type] = this.moEvents[type] || [];
                    var eventChild = event.oneOfChild;
                    switch(eventChild.className) {
                        case "script":
                            if(eventChild.value!=null && (eventChild.runAt === "server" || eventChild.value.trim().length >0))
                                this.moEvents[type].push(new xfalib.script.ExecutableScript({"jsonModel" : eventChild.jsonModel}));
                            break;
                        case "submit":
                            this.moEvents[type].push(new xfalib.script.Submit({"jsonModel" : eventChild.jsonModel}));
                            this._xfa()._newSubmitButton(this);  //TODO: What is it
                            break;
                    }
                }
            }

            var calcChild =  _.find(this.moChildNodes, function(childModel){
                return childModel.className == "calculate";
            });
            if(calcChild) {
                var calcScr = _.find(calcChild.moChildNodes, function(childModel){
                    return childModel.className == "script";
                });
                if(calcScr) {
                    this.moEvents["calculate"] = [new xfalib.script.CalculateScript({"jsonModel" : calcScr.jsonModel})];
                }
            }

            var validChild =  _.find(this.moChildNodes, function(childModel){
                return childModel.className == "validate";
            });
            if(validChild) {
                var validScr = _.find(validChild.moChildNodes, function(childModel){
                    return childModel.className == "script";
                });
                if(validScr) {
                    this.moEvents["validate"] = [new xfalib.script.ValidateScript({"jsonModel" : validScr.jsonModel})];
                }
            }

            //is it a good idea to create behaviorConfig at the formbridge or xfalib.runtime level???
            var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);

            //To maintain backward compatibility
            if(behaviorConfig.isOn('dataDependentFloatingField') || behaviorConfig.isOn('mfDataDependentFloatingField')) {
                //this is inserted by server when a draw element contains floating fields.
                var resolveChild = _.find(this.moChildNodes, function(childModel){
                    return childModel.className == "resolve";
                });
                if (resolveChild) {
                    this.moEvents["calculate"] = [];
                    this.moEvents["calculate"].push(new xfalib.script.FloatingFieldScript());
                }
            }
        },

        /**
         * @private
         * @function
         * @param {string} eventName Event Handler function to handle events thrown
         */
        _eventHandler : function(eventName) {
            var rValue = undefined;
            switch (eventName) {
                case "validate":
                    rValue = true;
                    break;
            }
            return rValue;
        },
        /**
         * @private
         * @function
         * returns if the node is eligible for validation or not based on the presence
         */
        _isEligibleForValidation : function() {
            return this.mEffectivePresence != "inactive";
        },

        _handleDependants: function() {
            for(var i =0;i<this.dependant.length;i++) {
                this._xfa().queueCalcEvent(this.dependant[i]);
            }
        },

        _isEventNode : function(){
            return true;
        },

        removeDependant: function(oNode) {
            this.dependant = _.without(oNode);       //TODO: What is it, no second argument?
        },

        _checkTests: function(sMessages) {
            var valid = true;
            var tests = this.tests || [];
            for(var i = 0;i<tests.length;i++) {
                valid = tests[i].apply(this,arguments);
                if(!valid)
                    break;
            }
            return valid;
        },

        _scriptTest : function(sMessages) {
            var valid = true;
            var valid = this.execEvent("validate");
            if (valid === false) {
                this._mFailedValTest = "scriptTest";
                this._mFailedValLevel  = this.getOrElse(this.validate.scriptTest, this._defaults.validate.scriptTest) ;
                this._errorText = this.validationMessage;
                this._addMessage(sMessages, this._errorText, this._mFailedValLevel);
            }
            return valid;
        },

        _validate : function(sMessages) {
            var oldFailedTest = this._mFailedValTest;
            var oldValid = this._errorText ? false : true;
            this._mFailedValTest = null;
            this._mFailedValLevel = null;
            this._errorText = null;
            var childValid = true;
            if (!this._isEligibleForValidation()) {
                return true;
            }
            if (this._xfa().host.validationsEnabled) {
                for ( var i = 0; i < this.moChildNodes.length; i++) {
                    var childNode = this.moChildNodes[i];
                    if(childNode._isEventNode()) {
                        childValid = this.moChildNodes[i]._validate(sMessages) && childValid;
                    }
                }
                var valid = this._checkTests(sMessages) && childValid;
                if(valid==false) {
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,"ValidationState",
                        this._mFailedValLevel, this._errorText);
                    this.trigger(evnt.name,evnt);
                    // true indicating that previously this field is not having error
                    // false indicating that now this field is having an error
                } else {
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                        this,"ClearError",null, null);
                    this.trigger(evnt.name,evnt);
                    // false indicating that previously this field is  having error
                    // true indicating that now this field is having an error i.e. error Cleared
                }
                xfalib.ut.XfaUtil.prototype._triggerOnBridge("elementValidationStatusChanged", this, "validationStatus", !valid, valid);
                //TODO: show the error to user.
                if (this._mFailedValTest != oldFailedTest || valid != oldValid)
                    this.execEvent("validationState");
            }
            return valid;
        },

        _addMessage : function(sMessages, sMessage, sSeverity) {
            if (sMessage) {
                var oMessageObject = new Object();
                oMessageObject.message = sMessage;
                oMessageObject.severity = sSeverity;
                oMessageObject.ref = this.somExpression;
                sMessages.push(oMessageObject);
            }
        },

        _calculateEffectiveAccess : function() {
            var parentAccess = this.parent ? this.parent.mEffectiveAccess: "open"
            var newEffAccess = (this.access === "open" && parentAccess)?parentAccess :this.access;
            if(this.mEffectiveAccess != newEffAccess)
            {
                var oldVal = this.mEffectiveAccess;
                this.mEffectiveAccess = newEffAccess;
                this._updateChildrenEffectiveAccess();
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                    this,"access",oldVal,this.mEffectiveAccess);
                this.trigger(evnt.name,evnt);
            }
        },

        _updateChildrenEffectiveAccess : function() {
            if(!this._isField()){ //Ideally isField check should not be here but a short cut for now since it's the only exception.
                _.each(this.moChildNodes, function(elem) {
                    if(elem._isEventNode())
                        elem._calculateEffectiveAccess();
                })
            }
        },

        /**
         * @private
         * @function
         * calculate effective presence which is used to identify whether current node have ancestor presence inactive
         * According to XFA SPEC : A new value, inactive, is defined for the ubiquitous presence property. When applied to containers
         * this prevents the container and its contents from processing calculations, validations, and events.
         * When an outer container contains inner containers, and the outer container has a presence value that restricts its behavior,
         * the inner containers inherit the outer container’s restricted behavior regardless of their presence value.
         */
        _calculateEffectivePresence : function() {
            if (this.presence) {     // only calculate effective presence if it contains presence property
                var parentPresence = this.getOrElse(this, "parent.mEffectivePresence", "visible"),
                    newEffPresence = null;
                if (parentPresence == "inactive" ) {
                    newEffPresence = "inactive";
                } else if (parentPresence == "hidden" && this.presence != "inactive") {
                    newEffPresence = "hidden";
                } else if (parentPresence == "invisible" && this.presence == "visible") {
                    newEffPresence = "invisible";
                } else {
                    newEffPresence = this.presence;
                }
                if(this.mEffectivePresence != newEffPresence) {
                    this.mEffectivePresence = newEffPresence;
                    this._updateChildrenEffectivePresence();
                }
            } else {
                this._updateChildrenEffectivePresence();
            }
        },

        /**
         * @private
         * @function
         * calculate effective presence for child node
         */
        _updateChildrenEffectivePresence : function() {
            if(!this._isField() && this.moChildNodes){
                _.each(this.moChildNodes, function(oNode) {
                    if(oNode._isEventNode())
                        oNode._calculateEffectivePresence();
                });
            }
        },

        playJson : function(pJsonModel) {
            //Only handle special properties which has private property in model. Need a review of access property
            if (this._xfa()._templateSchema.hasAttribute(this.className, 'access')) {
                this.access = pJsonModel.access;
            }
            if (this._xfa()._templateSchema.hasAttribute(this.className, 'presence')) {
                this.presence = pJsonModel.presence; //Watson bug 3787002 : presence property changed by server side scrip
            }
            EventContainerNode._super.playJson.call(this, pJsonModel);
        },

        scopeless : function() {
            // TODO: check isArea
            return this.getAttribute("name").length == 0;
        },

        _resetData : function() {
            for ( var i = 0; i < this.moChildNodes.length; i++) {
                var oNode = this.moChildNodes[i];
                oNode._resetData();
            }
        },

        nakedFieldReferences : function(nIndex, createGetterSetter,obj) {
            for ( var i = 0; i < this.moNormalizedChildren.length; i++) {
                var oNode = this.moNormalizedChildren[i];
                if(this._requireGetterSetter(oNode))
                    oNode.getNaked(nIndex, createGetterSetter, obj,this);
            }
        },

        // return the traversal object
        getTraversalObject : function () {
            var children = this.getOrElse(this, "jsonModel.children", null),
                traversalObj = null;
            if(children) {
                traversalObj = _.find(children, function(child){ return child._class == "traversal"; });
            }
            return traversalObj;
        },

        // return NEXT/FIRST traversal object based on the operation(first/next) provided
        getNextTraversalSom : function (operation) {
            var traverse = null,
                traversalRef = null,
                traversalObj = this.getTraversalObject();
            if (traversalObj && (traverse = traversalObj.children)) {
                if (operation == xfalib.template.Constants.firstTraversal) {
                    traversalRef = _.find(traverse, function(child){ return child.operation == xfalib.template.Constants.firstTraversal});
                } else { // only first and next are supported and if no operation is mentioned then it is treated as next
                    traversalRef = _.find(traverse, function(child){ return child.operation != xfalib.template.Constants.firstTraversal});
                }
            }
            // TO DO: add handling for script in reference
            return traversalRef && this.resolveNode(traversalRef.ref) ? this.resolveNode(traversalRef.ref).somExpression : null;
        }
    });

    EventContainerNode.defineProps({
        "validate" : {
            get : function() {
                return this.getElement("validate", 0);
            },
            set : function(val) {
                return this.setElement(val,"validate");
            }
        },

        "errorText" : {
            get : function(){
                return this._errorText || "";
            }
        },

        "validationMessage" : {
            get : function() {
                var m = this.getOrElse(this.validate.message.scriptTest, this._defaults.validate.message.defaultMessage);
                return m.value;
              },
            set : function(val) {
                var nodes = this.validate.message.nodes;
                if(nodes.namedItem("scriptTest") === null) {
                    var node = this._xfa().form.createNode("text","scriptTest");
                    nodes.append(node);
                }
                this.validate.message.scriptTest.value =val;
                this.execValidate() ;
            }

        },

        "access" : {
            get : function() {
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            },
            set : function(vAccess) {
                vAccess = this.validateInput(vAccess, this._getDataType("access"), this.jsonModel.access);
                if (this.jsonModel.access != vAccess) {
                    this.jsonModel.access = vAccess;
                    this._calculateEffectiveAccess();
                }
            }
        },

        "relevant" : {
            get : function() {
                return this.getAttribute("relevant");
            },
            set : function(val) {
                val = this.validateInput(val, this._getDataType("relevant"), this.jsonModel.relevant) ;
                if (this.getAttribute("relevant") != val) {
                    this.jsonModel.relevant = val;
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                        this,"relevant",null,val);
                    this.trigger(evnt.name,evnt);
                }
            }
        },

        "desc" : {
            get : function() {
                return this.getElement("desc",0)
            }
        }

    });

})(_,xfalib);
/**
 * @package xfalib.script.Content
 * @import xfalib.script.Node	
 * @fileOverview The file creates the Content Node Class required for XFA library
 * @version 0.0.1
 */

//goog.provide('com.adobe.xfa.scripting.Content');
//
//goog.require('com.adobe.xfa.scripting.Node');

(function(_, xfalib){
    var Content = xfalib.script.Content = xfalib.script.Node.extend({
        msClassName: "content",
        /**
         * @private
         * @function
         * @returns {boolean} returns whether the node is an instance of a content Node or not
         */
        _isContent : function() {
            return true;
        }
    });
})(_, xfalib);


/**
 * @package xfalib.script.NodeValue
 * @import xfalib.ut.Class
 */


(function (_, xfalib) {
    var NodeValue = xfalib.script.NodeValue = xfalib.script.Content.extend({

        _default: "value",
        initialize: function () {
            NodeValue._super.initialize.call(this);
            this.jsonModel._value = this.jsonModel._value || null;
            this._initialJsonString = JSON.stringify(this.jsonModel);
            this._modelChanged = false;
        },

        _initialize: function () {
            NodeValue._super._initialize.apply(this, arguments);
            if (this._isFieldDescendant()) {
                this._modelChanged = true;
            }

        },

        /*
         * converts a value into the designated type. null is a valid value
         * for all types. For invalid value it returns undefined
         */
        typedValue: function (val, contentType) {
            if (typeof val === "undefined")
                return undefined;
            if (val === null || val === "")
                return null;
            return val;
        },

        /*
         * returns the typed value. since we never store undefined values
         * it always returns valid value
         */
        getValue: function (contentType, skipTypeCheck) {
            if(skipTypeCheck === true) {
                return this.jsonModel._value;
            }
            return this.typedValue(this.jsonModel._value, contentType);
        },

        _storeValue: function (val, typeVal) {
            this.jsonModel._value = val;
        },

        /*
         * converts val to its typed version and if val is valid stores
         * it.
         * returns whether the new value is different from the old one.
         */
        setValue: function (val, skipTypeCheck) {
            var oldVal = this.jsonModel._value,
                typeVal = this.typedValue(val),
                retVal = false;

            if (skipTypeCheck === true || typeof typeVal !== "undefined") {
                this._storeValue(val, typeVal);
                retVal = this.typedValue(oldVal) !== typeVal;
                this._modelChanged = true;  // LC-5465 : all field's whose value is set is to be reflected in jsonDiff
            }
            return retVal;
        },

        equals: function (oVal) {
            return (this.getValue() === oVal.getValue());
        },

        _computeJsonDiff: function (diff_level) {
            /*
             * Since we do not maintain initialJson or templateJson for DOM elements, we use this approximate method to compute jsonDiff.
             * Since value API is not as simple as other DOM api, we simply compare old and new json string to check if anything has changed
             * seeAlso: DOMElement and GenericText
             */
            var jsonStr = JSON.stringify(this.jsonModel);
            var changed = (this._initialJsonString != jsonStr);
            if (this.name === "FS_DATA_SOM" && diff_level === 3) {
                changed = true;
                this._modelChanged = true;
            }
            var jsonDiff = changed ? this.jsonModel : {_class: this.className, name: this.jsonModel.name};
            if (!changed && this._modelChanged)
                jsonDiff._value = this.jsonModel._value;
            return {
                "changed": this._modelChanged,
                jsonDifference: jsonDiff
            };
        },

        _isFieldDescendant: function () {
            var grandParent = this.getOrElse(this, "parent.parent", null);
            if (grandParent && grandParent.className == "field") {
                return true;
            }
            else {
                return false;
            }

        },

        playJson: function (pJsonModel) {
            if (pJsonModel._value != this.jsonModel._value) {
                this._modelChanged = true;
            }
            NodeValue._super.playJson.apply(this, arguments);
            if (typeof pJsonModel._value == "undefined")
                this.jsonModel._value = null;
        }
    });

    NodeValue.defineProps({
        "presence": {
            get: function () { //i am not sure how to make this property undefined so just removed setters
                return undefined;
            }
        },

        "value": {
            get: function () {
                return this.getValue();
            },

            set: function (sValue) {
                this.setValue(sValue);
                var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED, this, this.className, null, this.value);
                this.trigger(event.name, event);
            }
        }

    });

})(_, xfalib);

/**
 * @package xfalib.script.ImageValue
 * @import xfalib.script.NodeValue
 */

(function (_, xfalib) {
    var ImageValue = xfalib.script.ImageValue = xfalib.script.NodeValue.extend({
        msClassName: "image"
    });
    ImageValue.defineProps({
        "href": {
            get: function () {
                return this.getAttribute("href");
            }
        }
    });
}(_, xfalib));/**
 * @package xfalib.script.TextValue
 * @import xfalib.script.NodeValue
 */

(function(_, xfalib){
    var TextValue = xfalib.script.TextValue = xfalib.script.NodeValue.extend({
        msClassName: "text",
        typedValue : function(val) {
            var tValue = TextValue._super.typedValue.call(this, val);
            if (tValue != null)
                tValue = tValue.toString();
            return tValue;
        }

    });

    TextValue.defineProps({
        "maxChars" : {
            get : function() {
                return this.getOrElse(this.jsonModel.maxChars, "0") ;
            },
            set : function(value) {
                if(value < 0 && value == parseInt(value))
                    value = "0";
                if(value >= 0 && value == parseInt(value))   {
                    this.jsonModel.maxChars = value;
                    value = (value == "0")?"255":value;
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                        this,"maxChars",value, null);
                    this.trigger(evnt.name,evnt);
                }
            }
        }
    })
})(_, xfalib);

/**
 * @package xfalib.script.ExDataValue
 * @import xfalib.script.NodeValue
 */

(function(_, xfalib, $){

    var ExDataValue = xfalib.script.ExDataValue = xfalib.script.NodeValue.extend({
        msClassName: "exData",
        initialize : function(){
            ExDataValue._super.initialize.call(this);
            this._transformToXFACompliantModel();
            this._$internalXMLDoc = null;
            this._origTmpltVal = null;
        },

        _transformToXFACompliantModel: function(){
            if(this.className === "exData" && this.jsonModel._value !== null && this.jsonModel._value.indexOf("<body xmlns=") === -1 && this.jsonModel._value.indexOf("<body") !== -1){
                var openingBodyTagIndex = this.jsonModel._value.indexOf('<');
                var endingBodyTagIndex = this.jsonModel._value.indexOf('>');
                var bodyTagString = this.jsonModel._value.substring(openingBodyTagIndex, endingBodyTagIndex+1);
                this.jsonModel._value = this.jsonModel._value.replace(bodyTagString, '<body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/" xfa:APIVersion="2.7.0.0">');
                // this.jsonModel._value = '<body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/" xfa:APIVersion="2.7.0.0">' + this.jsonModel._value + '</body>';
            }
        },

        _computeJsonDiff: function() {
            // richtext field value should not be empty string.
            if(this.jsonModel._class === "exData" && !this.jsonModel._value){
                this.jsonModel._value = JSON.parse(this._initialJsonString)._value;
                this._transformToXFACompliantModel();
            }
            return {"changed" : true,
                jsonDifference : this.jsonModel
            };
        },

        typedValue: function(val, contentType) {
            //if contentType is not passed -> derive it from contentType attribute
            if(!contentType)
                contentType = this.getAttribute("contentType");
            switch(contentType) {
                case "text/plain":
                    return ExDataValue._super.typedValue.apply(this,[val]);
                case "text/xml":
                    if(val == null || val.length == 0)
                         return null;
                    try {
                        this._$internalXMLDoc = $.parseXML(val);
                    } catch(e) {
                        this._xfa().Logger.error("Invalid XML for the field");
                        return undefined;
                    }
                    //IE 9 supports XMLSerializer
                    return XMLSerializer ? (new XMLSerializer()).serializeToString(this._$internalXMLDoc): val
                case "text/html":
                    if(!(val && xfalib.ut.XfaUtil.prototype.isHTML(val))) {
                        if(this._$internalHTML == null) {
                           this._$internalHTML = $("<body><p></p></body>");
                        }
                        this._$internalHTML.html(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(val));
                    } else {
                        var $val = $(val);
                        this._$internalHTML = $val;
                    }
                    return this._$internalHTML.text();
                default:
                    return ExDataValue._super.typedValue.apply(this,[val]);
            }
        },

        saveXML: function() {
            var prefix = '<?xml version="1.0" encoding="UTF-8"?>' +
                         '<exData contentType="text/html" xmlns="http://www.xfa.org/schema/xfa-template/3.6/">' +
                         '<body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/">',
                suffix = '</body></exData>',
                strXML = this.jsonValue;

                // TODO : use jQuery or XMLparser to do this more reliably
                if(strXML.indexOf("<body") >=0)
                    strXML = strXML.slice(strXML.indexOf(">", strXML.indexOf("<body"))+1);
                if(strXML.lastIndexOf("</body>") >=0)
                    strXML = strXML.slice(0,strXML.lastIndexOf("</body>"));

           return prefix + strXML + suffix ;
        },

        loadXML: function(strXML) {
        //TODO : add support for other params to loadXML, as of now all calls are equivalent to loadXML(x,true,true)
            var dispValue;
            if(strXML.indexOf("<body") != -1 && strXML.lastIndexOf("</body>") != -1) { // assuming a well formed valid XML string
                dispValue = strXML.slice(strXML.indexOf(">", strXML.indexOf("<body"))+1,strXML.lastIndexOf("</body>")); // get contents within <body> tags
            }
            if(this.getAttribute("contentType") == 'text/html') {
                if(dispValue.indexOf('<span>') != 0) {
                    dispValue = '<span>' + dispValue + '</span>';  // in case of multiple html elements, wrap in a span, else they overlap !!
                }

                var $internalHTML = $('<span>'+ dispValue +'</span>');
                $internalHTML.find("p").eq(0).css('display','inline');
                dispValue = $internalHTML.html();   // get the inner html with all markups

                this.jsonValue = dispValue;
            } else {
                dispValue = '<body>' + dispValue + '</body>';
                this.value = dispValue;
            }
          }
    });

    ExDataValue.defineProps({
        "jsonValue": {  // should use it to circumvent 'typedValue', which strips html tags
            get: function () {
                return this.jsonModel._value;
            },

            set: function (sValue) {
                if(_.isNull(this._origTmpltVal)) {
                    this._origTmpltVal = this.jsonModel._value;
                }
                this._modelChanged = true;  // just to be consistent & safe with 'value'

                if(sValue !== this.jsonModel._value) {
                    this.jsonModel._value = sValue;
                    var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED, this, this.className, null, sValue);
                    this.trigger(event.name, event);
                }
            }
        }
    });
})(_, xfalib, $);

/**
 * @package xfalib.script.IntegerValue
 * @import  xfalib.script.NodeValue
 */

(function(_, xfalib){
    var IntegerValue = xfalib.script.IntegerValue = xfalib.script.NodeValue.extend({
        msClassName: "integer",
        typedValue : function(val) {
            var tValue = IntegerValue._super.typedValue.call(this, val);
            if (tValue != null) {
                tValue = parseInt(tValue);
                if (isNaN(tValue))
                   tValue = undefined;
            }
            return tValue;
        }
    });
})(_, xfalib);
/**
 * @package xfalib.script.DecimalValue
 * @import xfalib.script.NodeValue
 */

(function(_, xfalib){
    var DecimalValue = xfalib.script.DecimalValue = xfalib.script.NodeValue.extend({
        msClassName: "decimal",

        typedValue : function(val) {
            var tValue = DecimalValue._super.typedValue.call(this, val);
            if (tValue) {
                tValue = parseFloat(tValue);
                if (isNaN(tValue))
                    return undefined;
                var str = tValue + '';
                var len = str.length;
                var leadD = str.indexOf(".");
                var fracD = len - leadD - 1;
                if(fracD > this.fracDigits && this.fracDigits != -1)
                    tValue = parseFloat(tValue.toFixed(this.fracDigits));
                if(leadD > this.leadDigits && this.leadDigits != -1)
                    tValue = null;
            }
            return tValue;
        }
    });

    DecimalValue.defineProps({
        "fracDigits" : {
            get : function(){
                return this.getAttribute("fracDigits")
            }
        },

        "leadDigits" : {
            get : function(){
                return this.getAttribute("leadDigits")
            }
        }
    });
})(_, xfalib);


/*
 * @package xfalib.script.FloatValue
 * @import xfalib.script.NodeValue
 */
  

(function(_, xfalib){
    var FloatValue = xfalib.script.FloatValue = xfalib.script.NodeValue.extend({

        msClassName: "float",
        typedValue : function(val) {
            var tValue = FloatValue._super.typedValue.call(this, val);
            if (tValue) {
                tValue = parseFloat(tValue);
                if (isNaN(tValue))
                    return undefined;
                
            }
            return tValue;
        }
    });
})(_, xfalib);/*
 * @package xfalib.script.DateValue
 * @import xfalib.script.NodeValue
 */


(function(_, xfalib){
    var DateValue = xfalib.script.DateValue = xfalib.script.NodeValue.extend({
        msClassName: "date",
        typedValue : function(val) {
            var tValue = DateValue._super.typedValue.call(this, val);
            if (tValue) {
                var tValueParsed = xfalib.ut.DateInfo.Parse(tValue, undefined, false);
                if (tValueParsed !== null) {
                    tValueParsed = tValueParsed.getISODate();
                }
                // if value is not correctly parsed then return the original value
                return tValueParsed ? tValueParsed : tValue;
            }
            return tValue;
        }
    });
})(_, xfalib);/**
 * @package xfalib.script.Form
 * @import xfalib.script.ContainerNode
 */

(function (_, xfalib) {
    /**
     * @class
     * <p>
     * The Form class is the implementation of the top level XFA form object.
     * </p>
     *
     * <p>
     * The form object is accessed from the xfa object as xfa.form
     * </p>
     *
     */
    var DataNode = xfalib.script.DataNode = xfalib.ut.Class.extend({
        initialize : function() {
            this.jsonModel.value = null;
            this.fields = [];
        },

        getId : function () {
            return this.jsonModel.id;
        },

        /**
         * will sync fields having same dataId (same bindref or use global)
         * @param model
         */
        addField : function (model) {
            if (this.fields.length === 0 && model.rawValue != null) { // loose check for null/undef
                this.jsonModel.value = model.rawValue; // initialize dataNode group's value to 1st hierarchically reached field
            } else {
                model.rawValue = this.jsonModel.value;
            }
            this.fields.push(model);
            model.on(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this);
        },

        handleEvent : function (evnt) {
            switch (evnt.name) {
                case xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED:
                    this.handleModelChanged(evnt);
                    break;
                default:
                    xfalib.runtime.xfa.Logger.debug("xfa", 'Unexpected  Event  "{0}" thrown in dataNode with id : "{1}" ', [evnt.name, this.jsonModel.id]);
            }
        },

        handleModelChanged : function (event) {
            if (event._property === "rawValue") {
                this._handleValueChange(event);
            }
        },

        _handleValueChange : function (event) {
            this._updateLinkedFieldsValue(event.prevText, event.target);
        },

        /**
         * will update all linked fields to the new value passed in
         * @param newValue
         * @param target
         * @private
         * @memberof DataNode
         */
        _updateLinkedFieldsValue : function (newValue, target) {
            if (newValue !== undefined && newValue != this.jsonModel.value) { // loose type coercion here for int/str
                this.jsonModel.value = newValue;

                _.each(this.fields, function (field) {
                    if (field !== target) {
                        field.off(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this); // remove listeners to prevent event throw storm
                        field.rawValue = newValue;
                        field.on(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this); // re attach listeners
                    }
                }, this);
            }
        }
    });
})(_, xfalib);
/**
 * @package xfalib.script.ExecutableScript
 * @import xfalib.ut.Class
 */


(function(_, xfalib){
    var ExecutableScript = xfalib.script.ExecutableScript = xfalib.ut.Class.extend({
        _defaults : {
            "runAt" : "client"
        },

        initialize : function(){
            ExecutableScript._super.initialize.call(this);
            this._scriptFn = null;
        },

        execute : function(contextObj, eventName) {
            // According to XFA SPEC : If the presubmit script is marked to be run only at the server, the data is sent to the server with an
            // indication that it should run the associated script before performing the rest of the processing. Client side script for presubmit
            // are executed before running validation.
            if(this.runAt == "server" && eventName != "$formpreSubmit") {
                var options = {};
                options.activity = this.xfaUtil()._xtgEventName[eventName] ? this.xfaUtil()._xtgEventName[eventName] : eventName;
                options.contextSom = contextObj.somExpression;
                contextObj._xfa().host.runServerScript(options);
            }
            else {
                return this._executeLocal(contextObj, eventName);
            }
        },

        _executeLocal :  function(contextObj, eventName) {
            try {
                this.script.call(contextObj);      // TODO : The best way will be to use `with` so that eval can also be used without modifying anything
            } catch(exception) {
                contextObj._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-002"],[eventName, contextObj.somExpression,exception.message])
            }
            return undefined;
        }

    });

    ExecutableScript.defineProps({
        "runAt" : {
            get : function(){
                return this.getOrElse(this.jsonModel.runAt, this._defaults.runAt);
            }
        },

        "script" : {
            get : function() {
                if(this._scriptFn == null) {
                    var scriptContent = this.jsonModel._value;
                    try{
                        var content = "with(this) {\n\n with(xfalib.runtime) {\n\n" + scriptContent + "\n\n}\n\n }";
                        this._scriptFn = new Function(content);
                    }catch(exception) {
                        xfalib.runtime.xfa.Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-005"],[exception.message,scriptContent]);
                        this._scriptFn = new Function("");
                    }
                }
                return this._scriptFn;
            }
        }


    });

})(_, xfalib);

/**
 * @package xfalib.script.ValidateScript
 * @import xfalib.script.ExecutableScript
 */

(function(_, xfalib){
    var ValidateScript = xfalib.script.ValidateScript = xfalib.script.ExecutableScript.extend({

        initialize : function() {
            ValidateScript._super.initialize.call(this);
        },

        evalScript: function () {
            with(this){
                with(xfalib.runtime) {
                    var __XFA_evalValidateScriptRetVal__ = eval(arguments[0]); // LC-7319 : variable names passed in 'eval' are overridden due to enclosing 'with'
                }
            }
            return __XFA_evalValidateScriptRetVal__;
        },

        _executeLocal :  function(contextObj, eventName) {
            var rValue = true;
            try {
                if(this.script)
                    rValue = this.evalScript.call(contextObj,this.script);
                if(!rValue)
                    contextObj._xfa().Logger.debug("xfa", xfalib.locale.LogMessages["ALC-FRM-901-014"],[contextObj.somExpression,this.script])
            } catch(exception) {
                contextObj._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-002"],[eventName, contextObj.somExpression,exception.message])
                rValue = true;
            }
            return rValue;
        }

    });

    ValidateScript.defineProps({
        "script" : {
            get : function() {
                return this.jsonModel._value;
            }
        }
    });

})(_, xfalib);
/**
 * @package xfalib.script.CalculateScript
 * @import xfalib.script.ValidateScript
 */
(function(_, xfalib){
    var CalculateScript = xfalib.script.CalculateScript = xfalib.script.ValidateScript.extend({

        _executeLocal :  function(contextObj, eventName) {
            var rValue ;
            if(this.script){
                // pre_process
                contextObj._xfa()._pushCalculateEventNode(contextObj);

                try {
                    contextObj.rawValue = this.evalScript.call(contextObj,this.script)
                } catch(exception) {
                    contextObj._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-002"],[eventName, contextObj.somExpression,exception.message])
                }

                // post_process
                contextObj._xfa()._popCalculateEventNode();
            }
            return rValue;
        }

    });
})(_, xfalib);
/**
 * Created with IntelliJ IDEA.
 * User: rpandey
 * Date: 11/27/13
 * Time: 10:26 AM
 */
/**
 * @package xfalib.script.FloatingFieldScript
 * @import xfalib.script.CalculateScript
 */
(function(_, xfalib){
    var FloatingFieldScript = xfalib.script.FloatingFieldScript = xfalib.script.CalculateScript.extend({
        //Do we really need new class for FloatingFieldScript just for a different error message and a different script

        _executeLocal :  function(contextObj, eventName) {
            if(contextObj._resolveFloatingField){
                // pre_process
                contextObj._xfa()._pushCalculateEventNode(contextObj);

                try {
                    //Call _resolveFloatingField in this context
                    //this hard-coding decouples the server from script function name...
                    //Now it is only at the client side we keep the name of floating fields resolver script
                    this.evalScript.call(contextObj, '_resolveFloatingField()');
                } catch(exception) {
                    contextObj._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-019"],[contextObj.somExpression])
                }

                // post_process
                contextObj._xfa()._popCalculateEventNode();

            }

            return undefined;
        }

    });
})(_, xfalib);
/**
 * @package xfalib.script.Submit
 * @import xfalib.ut.Class
 */

(function(_, xfalib){
    var Submit = xfalib.script.Submit = xfalib.ut.Class.extend({

        initialize : function() {
            Submit._super.initialize.call(this);
        },

        execute : function(obj, eventName) {
            var options = {};
            if(this.target)
                options.action = this.target;
            options.format = this.format;
            options.textEncoding = this.textEncoding;

            formBridge.submitForm(options); //TODO: remove direct dependency on FormBridge
        }

    });

    Submit.defineProps({
        format : {
            get : function(){
                return this.getOrElse(this.jsonModel.format, null);
            }
        },

        target : {
            get : function(){
                return this.getOrElse(this.jsonModel.target, null);
            }
        },

        textEncoding : {
            get : function(){
                return this.getOrElse(this.jsonModel.textEncoding, null);
            }
        }

    });
})(_, xfalib);
/**
 * @package xfalib.script.Field
 * @import xfalib.script.Node
 * @import xfalib.script.XfaModelEvent
 * @fileOverview The file creates the Field Class required for XFA library
 * @version 0.0.1
 */

(function (_, xfalib) {
    /**
     * Creates a new Field class
     *
     * @constructor
     * @param {string}
     *            name the name of the Field
     * @param {string}
     *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends xfalib.script.Node
     */
    var Field = xfalib.script.Field = xfalib.script.EventContainerNode.extend({
        _defaults: {
            "items": {
                "save": "0"
            }
        },

        "_default": "rawValue",
        initialize: function () {
            Field._super.initialize.call(this);
            this.jsonModel["{default}"] = this._getValue();
            this.tests = [this._nullTest, this._formatTest, this._scriptTest];
            if (this.jsonModel.extras && this.jsonModel.extras.dataId)
                this._xfa().createDataNode(this.jsonModel.extras.dataId, this);
            for (var i = 0; i < this.moChildNodes.length; ++i) {
                var oNode = this.moChildNodes[i];
                oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED, this);
            }
            if (this.jsonModel.id) {
                this._xfa().Logger.debug("xfa", "Added field with id :" + this.jsonModel.id)
                this._xfa()._xfaTemplateCache.idMap[this.jsonModel.id] = this;
            }

            this.editPattern = this.getOrElse(this.jsonModel, "extras.editPatternEx", null);
        },

        playJson: function (pJsonModel) {
            Field._super.playJson.call(this, pJsonModel);

            // update data node cached value
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'rawValue', this.rawValue, this.formattedValue);
            this.trigger(evnt.name, evnt);
        },

        _setPattern: function (type, patterns, callback) {
            if (patterns && patterns.length) {
                this.jsonModel.extras = this.jsonModel.extras || {};
                _.each(patterns, function (pattern, i) {
                    pattern.locale = pattern.locale || this.locale
                }, this);
                this.jsonModel.extras[type] = patterns;
                return true;
            }
            return false;
        },

        handleDomEvent: function (evnt) {
            switch (evnt._property) {
                case "format.picture":
                    var res = this._setPattern("displayPatternEx",
                        xfalib.ut.PictureUtils.parsePictureClause(evnt.newText));
                    if (res) {
                        this._showDisplayFormat();
                    }
                    break;
                case "validate.picture":
                    var res = this._setPattern("validatePatternEx",
                        xfalib.ut.PictureUtils.parsePictureClause(evnt.newText));
                    if (res) {
                        this._validate([]);
                    }
                default:
                    xfalib.script.EventContainerNode.prototype.handleDomEvent.apply(this,
                        arguments);
            }
        },

        saveXML: function () {
            return this.rawValue;
        },

        loadXML: function (val) {
            //this.rawValue = val;
        },


        addItem: function (sDisplayVal, sSaveVal) {
            //call _getDisplayItems before saving any SaveItems.
            var sItems = this._getSaveItems(true);
            var dItems = this._getDisplayItems(true);

            var saveItem = {
                "_class": "text",
                "_value": sSaveVal === undefined ? sDisplayVal : sSaveVal
            };

            sItems._addChild(xfalib.script.XfaModelRegistry.prototype.createModel(saveItem));

            var displayItem = {
                "_class": "text",
                "_value": sDisplayVal
            };

            dItems._addChild(xfalib.script.XfaModelRegistry.prototype.createModel(displayItem));

            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                this, "addItem", saveItem._value, displayItem._value);
            this.trigger(evnt.name, evnt);
        },

        _splitStringWithEscapedCommas: function (string) {
            var arr = [];
            var start = 0;
            // a negative lookup was avoided as it's not supported in rhino and IE 11
            for(var i = 0 ; i < string.length ; i++ ){
                if(string[i] === ',' && string[i-1]!== '\\' )// i-1 is safe because the commas are already delimited
                {
                    arr.push(string.substring(start, i).replace(/\\,/g, ','));
                    start = i + 1;
                }
            }
            arr.push(string.substring(start).replace(/\\,/g, ','));
            return arr;
        },

        setItems: function (string, pair) {
            pair = pair === undefined ? 1 : pair;
            var that = this;
            var val = null;
            this.clearItems();
            var array = null;
            if(string.indexOf('\\,') > -1){
                array = this._splitStringWithEscapedCommas(string);
            }
            else {
                array = string.split(',');
            }
            if (pair == 2) {
                array.forEach(function (entry, index) {
                    if (index % 2 == 1) {
                        that.addItem(elem, entry);
                        val = entry;
                    }
                    else
                        elem = entry;
                });
                if (array.length % 2)
                    that.addItem(elem);
                return true;

            }
            else if (pair == 1) {
                array.forEach(function (entry) {
                    that.addItem(entry);
                });
                return true;
            }
            else if (pair > 2)
                return  false;
            return;
        },

        clearItems: function () {
            var sItems = this._getSaveItems(false);
            var dItems = this._getDisplayItems(false);
            if (sItems)
                sItems._removeAll();
            if (dItems)
                dItems._removeAll();
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                this, "clearItems", null, null);
            this.trigger(evnt.name, evnt);
        },

        boundItem: function (sDisplayVal) {
            var dItems = this._getDisplayItems(false);
            var saveValue = null;
            _.find(dItems ? dItems.children : [],
                function (item, index) {
                    if (item.value == sDisplayVal) {
                        saveValue = this.getSaveItem(index); //This should always be present
                        return true;
                    }
                    else
                        return false;
                }, this
            );
            return saveValue;
        },

        getDisplayItem: function (nIndex) {
            var dItems = this._getDisplayItems(true);
            if (nIndex >= 0 && dItems && dItems.children.length > nIndex)
                return dItems.moChildNodes[nIndex].value;
            else
                return undefined; //Don't change
        },

        getSaveItem: function (nIndex) {
            var sItems = this._getSaveItems(true);
            if (nIndex >= 0 && sItems && sItems.children.length > nIndex)
                return sItems.moChildNodes[nIndex].value;
            else
                return undefined; //Don't change
        },

        getItemState: function (nIndex) {
            var itemValue = this.getOrElse(this.getSaveItem(nIndex), this.getDisplayItem(nIndex));
            if (itemValue !== null && itemValue !== undefined) {
                return this.rawValue == itemValue;
            }
            return null; // TODO: return null or false
        },

        setItemState: function (nIndex, bVal) {
            var itemValue = this.getOrElse(this.getSaveItem(nIndex), this.getDisplayItem(nIndex));
            if (itemValue !== null && itemValue !== undefined) {                      //TODO:Is it correct. What about Text and NumericInput?
                if (bVal)
                    this.rawValue = itemValue;
                else if (this.rawValue == itemValue)
                    this.rawValue = null;
            }
        },

        deleteItem: function (nIndex) {
            var sItems = this._getSaveItems(false);
            var dItems = this._getDisplayItems(false);
            if (nIndex >= 0 && sItems && sItems.moChildNodes.length > nIndex) //Check whether negative value of nIndex is a legal value??
                sItems._removeChild(sItems.moChildNodes[nIndex]);
            if (nIndex >= 0 && dItems && dItems.moChildNodes.length > nIndex) //Check whether negative value of nIndex is a legal value??
                dItems._removeChild(dItems.moChildNodes[nIndex]);
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                this, "deleteItem", null, nIndex);
            this.trigger(evnt.name, evnt);
        },

        execValidate: function () {
            return(this._validate([]));
        },

        nakedFieldReferences: function (nIndex, createGetterSetter, obj) {
            return;
        },

        _resetData: function (nIndex, bForce) {
            this.rawValue = this.jsonModel["{default}"];
        },

        _nullTest: function (sMessages) {
            var valid = true;
            var value = this._getValue();
            if ((value == null || value.length == 0) && this.mandatory != "disabled") {
                this._mFailedValTest = "nullTest";
                this._mFailedValLevel = this.mandatory;
                this._errorText = this.mandatoryMessage;
                this._addMessage(sMessages, this._errorText, this._mFailedValLevel);
                valid = false;
            }
            return valid;
        },

        _formatTest: function (sMessages) {
            var valid = true;
            var value = this._getValue();
            if (value)
                value += "";
            var picture = this.getOrElse(this.jsonModel,"extras.validatePatternEx", undefined);
            if (value != null && picture) {
                var retVal = this._formatValue(value, picture, 0);
                if (!retVal) {
                    this._setErrorData("formatTest", this.getOrElse(this.validate.formatTest, this._defaults.validate.formatTest), this.formatMessage);
                    this._addMessage(sMessages, this._errorText, this._mFailedValLevel);
                    valid = false;
                }
            }
            return valid;
        },

        _setErrorData: function (failedTest, failedLevel, errorText) {
            this._mFailedValTest = failedTest;
            this._mFailedValLevel = failedLevel;
            this._errorText = errorText;
        },

        _getSaveItems: function (createIfReqd) {
            var itemsList = this.
                _findChildren(xfalib.script.XfaModelRegistry.prototype.createSomExpression("items[*]"),
                true)
            var saveItems = itemsList._find(function (item, index) {
                return item.save == 1;
            });
            if (!saveItems && createIfReqd) {
                saveItems = xfalib.script.XfaModelRegistry.prototype.createModel({
                    _class: "items",
                    save: "1",
                    name: "items"
                });
                this._addChild(saveItems);
                var displayItems = itemsList._find(function (item, index) {
                    return item.save == 0;
                });
                saveItems.children = displayItems ? displayItems.moChildNodes : [];
            }
            if (saveItems)
                return saveItems;
            else
                return null;
        },

        _getDisplayItems: function (createIfReqd) {
            var itemsList = this.
                _findChildren(xfalib.script.XfaModelRegistry.prototype.createSomExpression("items[*]"),
                true)
            var displayItems = itemsList._find(function (item, index) {
                return item.save == 0;
            });
            if (!displayItems && createIfReqd) {
                displayItems = xfalib.script.XfaModelRegistry.prototype.createModel({
                    _class: "items",
                    name: "items"
                });
                this._addChild(displayItems);
                var saveItems = itemsList._find(function (item, index) {
                    return item.save == 1;
                });
                displayItems.children = saveItems ? saveItems.moChildNodes : [];
            }
            if (displayItems)
                return displayItems;
            else
                return this._getSaveItems();
        },

        _getValue: function (contentType, skipTypeCheck) {
            return this.value.oneOfChild.getValue(contentType, skipTypeCheck);
        },

        _setValue: function (sVal, skipTypeCheck) {
            return this.value.oneOfChild.setValue(sVal, skipTypeCheck);
        },

        _setHTMLValue: function(htmlStr) {
            // api to set the html value for cm use-case
            this._setValue(htmlStr, true);
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'rawValue', null, htmlStr);
            this.trigger(evnt.name, evnt);
        },

        _eventHandler: function (eventName) {
            var rValue = undefined;
            switch (eventName) {
                case "calculate":
                    if (this.moEvents["calculate"] && this.moEvents["calculate"].length > 0) {
                        rValue = this.moEvents["calculate"][0].execute(this, "calculate");
                    }
                    break;
                case "validate":
                    if (this.moEvents["validate"] && this.moEvents["validate"].length > 0) {
                        rValue = this.moEvents["validate"][0].execute(this, "validate");
                    } else
                        rValue = true;
                    break;
                case "$formpreSubmit":
                    rValue = this._preSubmitEventHandler();
                    break;
                default:
                    if (this.moEvents[eventName]) {
                        for (var i = 0; i < this.moEvents[eventName].length; i++) {
                            this.moEvents[eventName][i].execute(this, eventName);
                        }
                    }
            }
            return rValue;
        },

        _isField: function () {
            return true;
        },

        _showDisplayFormat: function () {
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'rawValue', this.rawValue, this.formattedValue);
            this.trigger(evnt.name, evnt);
        },

        _getDefaultPictureClause: function () {
            return "";
        },

        _formatValue: function (value, picture, force) {
            //testing specifically for only null and zero length string
            if (typeof value == "undefined" || value === null || value === "")
                return null;

            //force is same as bRelaxed , which is true in case of Display and false in case of parsing.
            force = force || false;
            if (picture) {
                var i = 0;
                for (; i < picture.length; i++) {
                    try {
                        var pattern = picture[i].category + "{" + picture[i].mask + "}";
                        return xfalib.ut.PictureFmt.format(value + "", pattern, picture[i].locale, force ,false);
                    } catch (exception) {
                        //continue to next pc
                    }
                }
            }
            if (force) {
                pattern = this._getDefaultPictureClause();
                try {
                    return xfalib.ut.PictureFmt.format(value + "", pattern, this.locale,force,true);
                } catch (exception) {
                    return value;
                }
            }
            return null;
        },

        _parseValue: function (value, picture) {
            if (typeof value === undefined)
                return value;

            if (picture) {
                var i = 0;
                for (; i < picture.length; i++) {
                    try {
                        var pattern = picture[i].category + "{" + picture[i].mask + "}";
                        return xfalib.ut.PictureFmt.parse(value, pattern, picture[i].locale);
                    } catch (exception) {
                        //continue to next pc
                    }
                }
            }
            pattern = this._getDefaultPictureClause();
            try {
                return xfalib.ut.PictureFmt.parse(value, pattern, this.locale);
            } catch (exception) {
                return value;
            }
        },


        _getLocale: function () {
            var obj = this;
            var locale;
            while (!locale && obj) {
                locale = obj.jsonModel.locale;
                obj = obj.parent;
            }
            locale = locale || this._xfa().defaultLocale;
            return locale;
        },

        scopeless: function () {
            return false;
        },

        _computeJsonDiff: function (diff_level) {
            //check bindings -> if it is none then this field is not needed in xml
            if (diff_level>0) {
                var bindElement = this.getElement("bind", 0, true);
                if (bindElement) {
                    if (bindElement.getAttribute("match") === "none" && diff_level === 2) {
                        return {
                            "changed": false,
                            "jsonDifference": {}
                        };
                    }
                }
            }
            return Field._super._computeJsonDiff.call(this, diff_level);
        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap : function(map) {
            if(!_.isObject(map)) {
                return map;
            }
            var datasom = this._getDataSom();
            if(datasom !== null) {
                map[datasom] = this.rawValue;
            }
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * The function does nothing if the map is not an object
         * @param map {object}
         * @private
         */
        _restoreDataSomMap : function (map) {
            if(!_.isObject(map)) {
                return;
            }
            var datasom = this._getDataSom();
            if (datasom != null && map[datasom] !== undefined) {
                this.rawValue = map[datasom];
            }
        },

        /**
         * Evaluates the given xpath relative to contextNode or RootNode depending upon the value of xpath.relative
         * In case it is true, xpath is evaluates relative to contextNode otherwise rootNode
         * For Fields, the value of xpath.relative can be "global" in which case we need to search the descendants of
         * the rootNode
         * @param xpath
         * @param contextNode
         * @param rootNode
         * @returns {*}
         * @private
         */
        _getElementsFromXpath: function(xpath, contextNode, rootNode) {
            var nodeIter,
                XMLUtils = xfalib.ut.XMLUtils,
                doc = rootNode instanceof Document ? rootNode : rootNode.ownerDocument;
            if(xpath.relative === "global") {
                nodeIter = XMLUtils.evaluateXPath("//"+xpath.bindRef, rootNode, null,
                    XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                return nodeIter;
            }
            return Field._super._getElementsFromXpath.apply(this, arguments);
        },

        _playDataXML: function(xmlDocument, contextNode, currentBindRef) {
            if(this.hasDataBinding()) {
                var xpath = this._getXpathFromBindRef(),
                    dataPattern = this.jsonModel.dataPattern,// TODO : ideally should read from bind.picture.value
                    result, node,
                    logger = this._xfa().Logger;
                if(xpath != null) {
                    result = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                    if(result != null) {
                        node = result.iterateNext();
                        if(node != null) {
                            var preFillValue = node.textContent;

                            if(_.isString(dataPattern)) {
                                var parsedPattern = xfalib.ut.PictureUtils.parsePictureClause(dataPattern);
                                if(_.isArray(parsedPattern) && parsedPattern.length === 1) {
                                    try {
                                        // CQ-4244983 : changing the formatTest condition. Cases where prefilled value
                                        // is properly formatted, value was not being parsed and the rawValue in model
                                        // was being stored in data pattern
                                        // Ex : data pattern is text{999-99-9999} and value is 123-45-6789
                                        // 1) for mobile forms rawValue being stored is 123456789
                                        // 2) for formset rawValue being stored was 123-45-6789
                                        // in case the parse is incorrect because of mismatch in data pattern and prefillValue
                                        // then there will be data loss
                                        // and if there is any exception while parsing then original value is stored.
                                         
                                        preFillValue = xfalib.ut.PictureFmt.parse(preFillValue, dataPattern);

                                        // note : numeric parse doesn't throw, but returns 0, need to take care of it later
                                    } catch (e) {
                                        // must set value to preserve prefill data on submit
                                        this._setValue(node.textContent, true);  // need to set value without type checking, for numeric field doesn't allow non numeric chars
                                        logger.warn("xfa",
                                            logger.resolveMessage(xfalib.locale.LogMessages["ALC-FRM-901-021"],
                                                [dataPattern, node.textContent, e]));
                                    }
                                } else {
                                    this._setValue(node.textContent, true);
                                    logger.warn("xfa",
                                        logger.resolveMessage(xfalib.locale.LogMessages["ALC-FRM-901-022"],
                                            [dataPattern, node.textContent]));
                                }
                            }
                            // bug in picturefmt numeric parse : cant parse patterns with ( or ), but doesnt throw, returns 0 instead
                            if (_.isString(dataPattern) &&
                                dataPattern.trim().indexOf("num") === 0 &&
                                (preFillValue == 0 && parseFloat(node.textContent.replace(/[^0-9]/g, "")) !== 0)) { // hack: if parser returns 0, and input has any non zero digit then parsing failed
                                this._setValue(node.textContent, true);
                                logger.warn("xfa",
                                    logger.resolveMessage(xfalib.locale.LogMessages["ALC-FRM-901-023"],
                                        [dataPattern, node.textContent]));
                            } else {
                                this._setValue(preFillValue);
                            }
                        }
                    } else {
                        this._resetData();
                    }
                }
            }
        },

        /**
         * Generates the XML by appending the elements in the rootNode
         * @param rootNode The rootNode of the xml. Generally the element that maps to the root of the form
         * @param contextNode Current Node where to insert the elements in case of relative bindings
         */
        generateDataXML: function (rootNode, contextNode) {
            if(this.hasDataBinding()) {
                var xpath = this._getXpathFromBindRef(),
                    relativeXPath, nodeIter, nodeList = [], result, node;
                if(xpath != null) {
                    var element = xpath.relative === false || xpath.relative === "global" ? rootNode : contextNode;
                    element = xfalib.ut.XMLUtils.createElementsFromXPath(xpath.bindRef, element, false);
                    this._appendValueInXMLElement(element);
                }
            }
        },

        _appendValueInXMLElement: function (element) {
            if(element != null) {
                element.textContent = this._getValue(null, true); // LC-3911180 : need to circumvent type check to preserve data
            }
        },

        /**
         * @private
         * @function
         * executes presubmit event scripts and check for cancelAction property
         * return false if the cancelAction property is set true
         */
        _preSubmitEventHandler : function () {
            if (this.moEvents["$formpreSubmit"] && this.moEvents["$formpreSubmit"].length > 0) {
                this.moEvents["$formpreSubmit"][0].execute(this, "$formpreSubmit");
                // If a script invoked by the pre-submit event sets $event.cancelAction, the submit action does not take place
                if (this._xfa().event.cancelAction) {
                    return false;
                }
            }
            return true;
        }

    });

    Field.defineProps({
        "locale": {
            get: function () {
                if (!this._locale)
                    this._locale = this._getLocale();
                return this._locale;
            }
        },

        "multiLine": {
            get: function () {
                return (this.ui.oneOfChild.multiLine == 1);
            }
        },

        "rawValue": {
            get: function () {
                var currentNode = this._xfa().moCalculateEventNode;
                if (currentNode != null) {
                    this.addDependant(currentNode);
                    currentNode.on(xfalib.script.XfaModelEvent.OBJECT_DESTROYED, this);
                }
                return this._getValue(null, this.value.oneOfChild.getAttribute("contentType") === "text/html");
            },
            set: function (oValue) {
                oValue = this.validateInput(oValue, "string");
                if (this.value.oneOfChild.maxChars && this.value.oneOfChild.maxChars !== "0" && oValue && this.value.oneOfChild.maxChars < oValue.length)
                    oValue = oValue.slice(0, this.value.oneOfChild.maxChars);
                var oldval = this._getValue();
                if (this._setValue(oValue, this.value.oneOfChild.getAttribute("contentType") === "text/html")) {
                    this._handleDependants();
                    this._xfa().queueValidateEvent(this);
                }
                if (oldval != oValue)
                    this._showDisplayFormat();
            }
        },

         "font": {
                    get : function() {
                        return  this.getElement("font",0);
                    } ,
                    set :function(value) {
                          this.setElement(value,"font");
                    }
                },

        "fontColor" : {
            get : function () {
                return this.getElement("font", 0).getElement("fill", 0).getElement("color", 0).value;
            },
            set : function (value) {
                this.getElement("font", 0).getElement("fill", 0).getElement("color", 0).value = value;
            }
        },

        "value" : {
            get : function() {
                return  this.getElement("value",0);
            },
            set: function () {}
        },

        //TODO: Note: Below handling should handle both multiSelect and single Selects. Need to verify this.
        "selectedIndex": {
            get: function () {
                var value = this.rawValue;
                var itemSize = this.length;
                if (itemSize >= 0) {
                    for (var i = 0; i < itemSize; i++) {
                        var selected = this.getItemState(i);
                        if (selected)
                            return i;
                    }
                }
                return -1;   //default -1
            },
            set: function (nIndex) {
                nIndex = this.validateInput(nIndex, "string");
                this._setValue(null);
                this.setItemState(nIndex, true);
            }
        },

        "length": {
            get: function () {
                var items = (this._getSaveItems(false) || this._getDisplayItems(false));
                return items ? items.moChildNodes.length : 0;
            }
        },

        "parentSubform": {
            get: function () {
                var temp = this.parent;
                while (temp && temp.className !== "subform")
                    temp = temp.parent;
                return temp;
            }
        },

        "mandatory": {
            get: function () {
                return this.getOrElse(this.validate.nullTest, this._defaults.validate.nullTest);
            },
            set: function (value) {
                if (this.validate) {
                    this.validate.nullTest = value;
                }
            }
        },

        "mandatoryMessage": {
            get: function () {
                return xfalib.ut.XfaUtil.prototype._getMandatoryMessage(this);
            },
            set: function (val) {
                var nodes = this.validate.message.nodes;
                if (nodes.namedItem("nullTest") === null) {
                    var node = this._xfa().form.createNode("text", "nullTest");
                    nodes.append(node);
                }
                this.validate.message.nullTest.value = val;
                this.execValidate();
            }
        },

        "formatMessage": {
            get: function () {
                var msg = this.getOrElse(this.validate, "message.formatTest", this._defaults.validate.message.defaultMessage);
                return msg.value;
            },
            set: function (val) {
                var nodes = this.validate.message.nodes;
                if (nodes.namedItem("formatTest") === null) {
                    var node = this._xfa().form.createNode("text", "formatTest");
                    nodes.append(node);
                }
                this.validate.message.formatTest.value = val;
                this.execValidate();
            }
        },

        "formattedValue": {
            get: function () {
                return this._formatValue(this._getValue(), this.jsonModel.extras.displayPatternEx, true);
            },
            set: function (val) {
                this.rawValue = this._parseValue(val, this.jsonModel.extras.displayPatternEx);
            }
        },

        "isNull": {
            get: function () {
                if (this._getValue() != null)
                    return false;
                else return true;
            }
        },

        "editValue": {
            get: function () {
                return this._formatValue(this._getValue(), this.jsonModel.extras.editPatternEx, true);
            }
        },

        ui: {
            get: function () {
                return this.getElement("ui", 0);
            },

            set: function (value) {
                this.setElement(value, "ui");
            }
        },

        "items": {
            get: function () {
                return this.getElement("items", 0);
            }
        },

        "calculate": {
            get: function () {
                return this.getElement("calculate", 0);
            }
        },

        "format": {
            get: function () {
                return this.getElement("format", 0);
            }
        }


    });

    Field.addMixins([
        xfalib.script.mixin.AddAssist,
        xfalib.script.mixin.AddCaption,
        xfalib.script.mixin.AddPresence,
        xfalib.script.mixin.AddXYWH,
        xfalib.script.mixin.AddFillColor,
        xfalib.script.mixin.AddBorder,
        xfalib.script.mixin.AddBorderColor,
        xfalib.script.mixin.AddBorderWidth,
        xfalib.script.mixin.AddPara,
        xfalib.script.mixin.AddMargin
    ]);

})(_, xfalib);








/**
 * @package xfalib.script.Draw
 * @import xfalib.script.Node
 * @fileOverview The file creates the Draw Class required for XFA library
 * @version 0.0.1
 */

(function (_, xfalib, $) {
    /**
     * Creates a new Draw class
     *
     * @constructor
     * @param {string}
     *            name the name of the Draw
     * @extends com.adobe.xfa.scripting.Node
     */
    var Draw = xfalib.script.Draw = xfalib.script.EventContainerNode.extend({

        _setValue: xfalib.script.Field.prototype._setValue,

        _getValue: xfalib.script.Field.prototype._getValue,

        _getFieldById: function (fieldId) {

            if (this._xfa()._xfaTemplateCache.idMap.hasOwnProperty(fieldId)) {
                //xtg uses just the name of the field to find the actual context node
                //this is a quick and dirty way to ensure index affinity
                //just to be in sync with XTG, I am using the same implementation as XFALayoutTextResolver class
                var field = this._xfa()._xfaTemplateCache.idMap[fieldId];
                var resolvedField = null;

                var bQuit = false;
                var index = 0;
                //TODO : Can we have problem in context object setting while doing index affine resolutions ?
                while (!bQuit)
                {
                    var som = field.name + '[' + index + ']';
                    //this will be done in the context of _resolveFloatingField
                    var probField = this.resolveNode(som);
                    if (!_.isEmpty(probField)) {
                        if (probField.jsonModel.id === field.jsonModel.id) {
                            bQuit = true;
                            resolvedField = probField;
                        }
                        else {
                            //keep looking
                        }
                    }
                    else { //this will not be used very often in fact I kept it just for completeness...
                        bQuit = true;
                        var nodeName = this;
                        //vdua suggests to use xfa.form..nodeName instead of _filterNodes.
                        //it takes care of index affinity also which is a bit unpredictable
                        //Let's try this in next iteration
                        var contextNodes = this._xfa().form._filterNodes(function (n) {
                            return n.name == nodeName;
                        });

                        var occurrenceToLookFor = 0;

                        for (var i = 0; i < contextNodes.length; i++) {
                            if (contextNodes.item(i) == this) {
                                occurrenceToLookFor = i;
                                break;
                            }
                        }

                        var floatingFieldNodes = this._xfa().form._filterNodes(function (n) {
                            return n.name == field.name;
                        });

                        var occurrence = 0;
                        var foundAtLeastOneMatch = false;
                        var indexOfFirstFound = 0;

                        for (var j = 0; j < floatingFieldNodes.length; j++) {
                            var probField = floatingFieldNodes.item(j);
                            if (probField.jsonModel.id == field.jsonModel.id) {
                                if (!foundAtLeastOneMatch)
                                    indexOfFirstFound = j;
                                foundAtLeastOneMatch = true;
                                if (occurrenceToLookFor == occurrence)
                                    return probField;
                                occurrence++;
                            }
                        }

                        if (foundAtLeastOneMatch)
                            return floatingFieldNodes.item(indexOfFirstFound);
                    }
                    index++;
                }
                return resolvedField;
            }
            else
                return null;
        },

        _computeJsonDiff: function (diff_level) {
            return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level === 2, xfalib.script.Node.prototype._computeJsonDiff, arguments);
        },

        playJson : function(pJsonModel) {
            //Do not do any playJson for draw children. It should not impact floating fields.
            xfalib.script.Node.prototype.playJson.apply(this, arguments);
        },

        _playDataXML: function () {

        },

        generateDataXML: function (rootNode, contextNode) {

        },

        _resolveFloatingField: function () {
            //Can we somehow store embeds and html text in Draw object and compute it over and over again
            //may we need another NodeValue type to handle it????

            if (this.value) {
                var content = this.value.oneOfChild;
                if (content.getAttribute('contentType') === 'text/html') {
                    if(_.isNull(content._origTmpltVal)){
                        content._origTmpltVal = content.jsonValue; // save original template info containing the embed tags
                    }
                    var isTextEmbeds = false,
                        that = this,
                        htmlText = content._origTmpltVal;
                    htmlText = htmlText.replaceAll("</br>","");
                    var $internalHTML = $('<span>' + htmlText + '</span>');
                    //change the top level element to span to wrap up all the <p>, because it will cause unnecessary paragraph break

                    //no null check because jQuery is cool!
                    $internalHTML.find("p").eq(0).css('display', 'inline');

                    $internalHTML.find('[xfa\\:embed]').each(function (index, span) {
                        isTextEmbeds = true;
                        var $span = $(span);
                        var embed = $span.attr('xfa:embed');
                        var embedType = $span.attr('xfa:embedType');
                        var embedMode = $span.attr('xfa:embedMode');
                        if (embed && embed.length > 1 && embed[0] == '#') {
                            embed = embed.substr(1);
                            //resolve Node will take care of index affinity here
                            var field = (embedType == 'uri') ? that._getFieldById(embed) : that.resolveNode(embed);
                            if (field) {
                                if (embedMode === 'raw') {
                                    if (field.rawValue == null)
                                        $span.replaceWith(field.rawValue);
                                    else
                                        $span.replaceWith($.parseHTML(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(field.rawValue.toString())));
                                }
                                else
                                    $span.replaceWith(xfalib.ut.XfaUtil.prototype.encodeScriptableTags(field.formattedValue.toString()));
                            }
                            else {
                                that._xfa().Logger.debug("xfa", "referred field with id " + embed + " doesn't exist.");
                                $span.remove();
                            }
                        }
                        else {
                            that._xfa().Logger.debug("xfa", "referred field with invalid id " + embed + " doesn't exist.");
                            $span.remove();
                        }
                    });

                    //isTextEmbeds is set to true if there is any embedded text field.
                    if (isTextEmbeds) {
                        content.jsonValue = "<span>" + $internalHTML.html() + "</span>";
                        // pages may not yet be rendered, but initialize called due to "initial count" of rpt. SF
                        // record updated value to be applied in _syncFormNodeToHtml during pg. render
                    }
                }
            }
        },

        scopeless: function () { //[LC-8801] DOM Properties of draw gets incorrectly attached
            return false;
        },

        _eventHandler: function (eventName) {
            //want to handle only calculate event that too in case of draw text
            if (this.ui && this.ui.oneOfChild && this.ui.oneOfChild.className == 'textEdit') {
                var rValue = undefined;
                switch (eventName) {
                    case "calculate":
                        if (this.moEvents["calculate"] && this.moEvents["calculate"].length > 0) {
                            this.moEvents["calculate"][0].execute(this, "calculate");
                        }
                        break;
                    default :
                        return Draw._super._eventHandler.call(this);
                }
                return rValue;
            }
            else
                return Draw._super._eventHandler.call(this);

        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap: function (map) {
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * @param map
         * @private
         */
        _restoreDataSomMap : function (map) {

        }
    });

    Draw.defineProps({
        "rawValue": {
            get: function () {
                return this._getValue();
            },
            set: function (sValue) {
                var oldval = this._getValue();
                sValue = this.validateInput(sValue, "string");
                this._setValue(sValue);
                var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this, 'rawValue', null, sValue);
                this.trigger(event.name, event);
            }
        },

        ui: {
            get: function () {
                return this.getElement("ui", 0);
            },

            set: function (value) {
                this.setElement(value, "ui");
            }
        },

        "font": {
            get: function () {
                return  this.getElement("font", 0);
            },
            set: function (value) {
                this.setElement(value, "font");
            }
        },

        "value": {
            get: function () {
                return  this.getElement("value", 0);
            },
            set: function (val) {
                this.setElement(val, "value");
            }
        },

        "desc": {
            get: function () {
                return this.getElement("desc", 0)
            }
        }
    });

    Draw.addMixins([
        xfalib.script.mixin.AddAssist,
        xfalib.script.mixin.AddCaption,
        xfalib.script.mixin.AddXYWH,
        xfalib.script.mixin.AddPresence,
        xfalib.script.mixin.AddBorder,
        xfalib.script.mixin.AddPara,
        xfalib.script.mixin.AddMargin
    ]);

})(_, xfalib, $);





/**
 * @package xfalib.script.DateTimeField
 * @import xfalib.script.Field
 * @fileOverview The file creates the Date Time Field Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new Date Time Field class
     *
     * @constructor
     * @param {string}
        *            name the name of the Field
     * @param {string}
        *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends com.adobe.xfa.scripting.Node
     */
    var DateTimeField = xfalib.script.DateTimeField = xfalib.script.Field.extend({
        _getDefaultPictureClause: function() {
            //watson bug#3672364 and 3672367.
            //Start reading calendar picture format from the localeset.
            if(this.value.oneOfChild.className === "date")
                return "date{"+this._xfa()._getLocaleSymbols(this.locale,"datePatterns").med+"}";
            else
                return "";
        },

        _setValue: function (sVal, skipTypeCheck) {
            return DateTimeField._super._setValue.call(this, sVal, skipTypeCheck);
        },

        _showDisplayFormat: function () {
            var formattedValue = this.formattedValue,
                rawValue = this.rawValue;
            // if formattedValue is null then show rawValue in widget along with error message
            if (!formattedValue) {
                formattedValue = rawValue;
            }
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this,
                'rawValue', rawValue, formattedValue);
            this.trigger(evnt.name, evnt);
        }
    });
})(_, xfalib);
/**
 * @package xfalib.script.NumericField
 * @import xfalib.script.Field
 * @fileOverview The file creates the Numeric Field Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new Numeric Field class
     *
     * @constructor
     * @param {string}
        *            name the name of the Field
     * @param {string}
        *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends com.adobe.xfa.scripting.Node
     */
    var NumericField = xfalib.script.NumericField = xfalib.script.Field.extend({
         _getDefaultPictureClause: function() {
            return "num{"+this._xfa()._getLocaleSymbols(this.locale,"numberPatterns").numeric+"}";
         }
    });
})(_, xfalib);
/**
 * @package xfalib.script.ButtonField
 * @import xfalib.script.Field
 * @fileOverview The file creates the Button Field Class required for XFA
 *               library
 * @version 0.0.1
 */

(function (_, xfalib) {
    var ButtonField = xfalib.script.ButtonField = xfalib.script.Field.extend({
        _computeJsonDiff: function (diff_level) {
            //we don't want button to appear in final submit, but for restoreFormState
            return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level === 2, ButtonField._super._computeJsonDiff, arguments);
        }
    });
})(_, xfalib);

/**
 * @package xfalib.script.CheckButtonField
 * @import xfalib.script.Field
 */
/**
 * @fileOverview The file creates the CheckButton Field Class required for XFA
 *               library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new CheckButtonField Field class
     *
     * @constructor
     * @param {string}
        *            name the name of the Field
     * @param {string}
        *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends com.adobe.xfa.scripting.Node
     */
    var CheckButtonField = xfalib.script.CheckButtonField = xfalib.script.Field.extend({
        initialize : function(){
            CheckButtonField._super.initialize.call(this);
            this._on = 0;
            this._off = 1;
            this._neutral = 2;
        },

        addItem : function(sDisplayVal, sSaveVal) {
            if (this.length == this._getMaxItems())
                return;
            CheckButtonField._super.addItem.call(this, sDisplayVal, sSaveVal);
        },

        _getMaxItems : function(){
            return this._allowNeutral() ? 3 : 2;
        },

        _allowNeutral : function(){
            return this.ui.oneOfChild.allowNeutral == 1 ? true : false;
        },

        _handleDependants : function() {
            CheckButtonField._super._handleDependants.call(this);
            if (this.parent._isExclusionGroup()) {
                this.parent._handleSelectChild(this);
            }
        }

    });
})(_, xfalib);
/**
 * @package xfalib.script.ChoiceListField
 * @import xfalib.script.Field
 */
/**
 * @fileOverview The file creates the ChoiceList Field Class required for XFA
 *               library
 * @version 0.0.1
 */


(function(_, xfalib, $){
    /**
     * Creates a new ChoiceList Field class
     *
     * @constructor
     * @param {string}
        *            name the name of the Field
     * @param {string}
        *            rawVal initial value of the Field
     * @property {string} rawVal represents the data value in the node
     * @extends com.adobe.xfa.scripting.Node
     */
    var ChoiceListField = xfalib.script.ChoiceListField = xfalib.script.Field.extend({

        initialize : function () {
            ChoiceListField._super.initialize.call(this);
            // to handle the scenario where bindRef items were not getting populated on adding new instance
            if (this.getElement("#bindItems") && xfalib.runtime.renderContext.data) {
                var prefillXmlDoc = xfalib.ut.XMLUtils.getXFARootFormElementFromXML($.parseXML(xfalib.runtime.renderContext.data));
                this._playItems(prefillXmlDoc, null);
            }
        },

        _convertValueToXml: function(val) {
           if(val == null || val.length == 0)
                return null
           var xml = "<"+this.name+">"
           _.each((val+"").split("\n"),function(value) {
               if(value && value.length > 0)
                    xml +="<value>"+value+"</value>"
            })
            xml += "</"+this.name+">"
            return xml
        },

        _getText: function(xml,sep,$) {
            var recText = function(obj,arr) {
                if(obj.children().length) {
                    obj.children().map(function(indx,child) {
                        recText($(child),arr);
                    })
                } else {
                    arr.push(obj.text());
                }
            };
            var arr = [];
            recText($($.parseXML(xml)),arr);
            return arr.join(sep);
        },

        _convertXmlToValue: function($xml) {
            if($xml == null)
                return null;
            return this._getText($xml,"\n",$);
        },

        _getValue : function() {
            var value = ChoiceListField._super._getValue.apply(this, this._multiSelect() ? ["text/xml"] : []);
            if(this._multiSelect())
                return this._convertXmlToValue(value);
            else
                return value
        },

        _setValue : function(sVal) {
            if(this._multiSelect())
                sVal = this._convertValueToXml(sVal);
            return ChoiceListField._super._setValue.apply(this,[sVal]);
        },

        getItemState : function(nIndex) {
            if (this._multiSelect() !== false) {
                var saveValue = this.getSaveItem(nIndex);
                if(saveValue!== null && saveValue!== undefined){
                    saveValue = ""+saveValue;
                    var valueArray = (this.rawValue + "").split("\n");
                    var currentValIndex = this.xfaUtil().dIndexOf(valueArray,saveValue);
                    return currentValIndex >= 0;
                } else
                    return null; // TODO: return null or false
            } else {
                return ChoiceListField._super.getItemState.call(this, nIndex);
            }

        },

        // returns array of indices corresponding to selected value
        _selectedLastIndices : function() {
            var itemSize = this.length,
                lastSelectedIndices = [];

            for (var i=0; i< itemSize; i++) {
                if (this.getItemState(i)) {
                    lastSelectedIndices.push(i);
                }
            }
            return lastSelectedIndices;
        },

        // returns display value corresponding to selected value
        _formatValue: function () {
            var lastSelectedIndices = this._selectedLastIndices();
            return lastSelectedIndices.map( function (selIndex) {
                return this.getDisplayItem(selIndex);
            }, this).join("\n");
        },

        _multiSelect : function(){
            return this.ui.oneOfChild.open == "multiSelect" ? true : false;
        },



        setItemState : function(nIndex, bVal) {
            if (this._multiSelect() !== false) {
                var saveValue = this.getSaveItem(nIndex);
                if(saveValue !== null && saveValue !== undefined) {
                    saveValue = ""+saveValue;
                    var valueArray = (this.rawValue + "").split("\n");
                    var currentValIndex = this.xfaUtil().dIndexOf(valueArray,saveValue); /*item value is typed so converting it to string for matching */
                    if(bVal && currentValIndex < 0) {
                        var saveItems = this._getSaveItems().children
                        var newValArray = _.reduce(saveItems,function(memo,item) {
                                if(this.xfaUtil().dIndexOf(valueArray,item.value) >= 0 || item.value == saveValue)
                                    memo.push(item.value);
                                return memo
                        },[],this)
                        valueArray = newValArray;
                    }
                    else if(!bVal && currentValIndex >=0)
                        valueArray.splice(currentValIndex, 1)
                    this.rawValue = valueArray.join("\n");
                }
            } else {
                ChoiceListField._super.setItemState.call(this, nIndex, bVal);
            }
        },

        _playDataXML: function (xmlDocument, contextNode, currentBindRef) {
            var xpath = this._getXpathFromBindRef(),
                value, nodeIter, node;
            if(xpath != null) {
                if(this._multiSelect()) {
                    // in case of multiselect the value is xml and hence needs special processing
                    nodeIter = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                    var node = nodeIter.iterateNext();
                    if(node != null) {
                        value = new XMLSerializer().serializeToString(node);
                        ChoiceListField._super._setValue.apply(this,[value]);
                        //todo: If we move processing of data xml before view
                        //generation then showDisplayFormat call will not be needed.
                        this._showDisplayFormat();
                    }
                } else {
                    ChoiceListField._super._playDataXML.apply(this, [xmlDocument, contextNode, currentBindRef]);
                }
            }
            this._playItems(xmlDocument, contextNode);
        },

        _playItems: function (xmlDocument, contextNode) {
            var bindItems = this.getElement("#bindItems[0]");
            if (bindItems != null) {
                var connection = bindItems.connection;
                if (connection == null || connection.length == 0) {
                    var ref = bindItems.ref;
                    if (ref != null && ref.length > 0) {
                        var xpath = this._convertRefToXPath(ref);
                        if (xpath != null) {
                            var itemNodes = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                            if (itemNodes != null) {
                                this.clearItems();
                                var itemNode = itemNodes.iterateNext();
                                var xmlUtils = xfalib.ut.XMLUtils;
                                while (itemNode != null) {
                                    //TODO: support valueRef/labelRef with xPath having more than one element
                                    // and valueRef/labelRef pointing to an attribute
                                    var valueNodeResult = xmlUtils.evaluateXPath(bindItems.valueRef, itemNode, null,
                                        XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                                    if (valueNodeResult != null) {
                                        var labelNodeResult = valueNodeResult;
                                        if (bindItems.labelRef) {
                                            labelNodeResult = xmlUtils.evaluateXPath(bindItems.labelRef, itemNode, null,
                                                XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                                        }
                                        var valueNode = valueNodeResult.iterateNext();
                                        if(valueNode != null) {
                                            var labelNode = labelNodeResult ? labelNodeResult.iterateNext() : null;
                                            if(labelNode == null) {
                                                labelNode = valueNode;
                                                this._xfa().Logger.warn("xfa",
                                                        "labelRef doesn't exist for [" + this.somExpression + ","
                                                        + bindItems.ref + "," + bindItems.labelRef + "]");
                                            }
                                            this.addItem(labelNode.textContent,
                                                valueNode.textContent);
                                        } else {
                                            this._xfa().Logger.error("xfa",
                                                    "valueRef doesn't exist for [" + this.somExpression + ","
                                                        + bindItems.ref + "," + bindItems.labelRef + "]");
                                        }
                                    } else {
                                        this._xfa().Logger.error("xfa", "valueRef points to an invalid xml element "
                                            + bindItems.valueRef);
                                    }

                                    itemNode = itemNodes.iterateNext();
                                }
                            }
                        }
                    }
                } else {
                    this._xfa().Logger.warn("xfa", "connection in bindItems is not supported in Formset");
                }
            }
        },

        _appendValueInXMLElement: function (element) {
            if(!this._multiSelect()) {
                ChoiceListField._super._appendValueInXMLElement.apply(this,[element]);
            } else {
                // need to remove the old choices before appending the new ones
                while (element.firstChild) {
                    element.removeChild(element.firstChild);
                }
                var xmlValue = this.value.oneOfChild.getValue("text/xml"),
                    xmlDoc, nodeIter, node, importedNode, addedChild;
                if(xmlValue != null && xmlValue != "") {
                    xmlDoc = $.parseXML(xmlValue);
                    nodeIter = xfalib.ut.XMLUtils.evaluateXPath("*", xmlDoc.documentElement, null,
                                                                    XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
                    node = nodeIter.iterateNext();
                    while(node != null) {
                        importedNode = element.ownerDocument.importNode(node, false);
                        addedChild = element.appendChild(importedNode);
                        addedChild.textContent = node.textContent;
                        node = nodeIter.iterateNext();
                    }
                }
            }
        }
    });
})(_, xfalib, $);
/**
 * @package xfalib.script.Subform
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the Subform Class required for XFA library
 * @class The class represents a subform in the XFA Dom
 * @version 0.0.1
 */
(function(_,xfalib){
    var Subform = xfalib.script.Subform = xfalib.script.EventContainerNode.extend({
        initialize: function() {
            Subform._super.initialize.call(this);
            this._instanceManager = null;
            this.mnInstanceIndex = 0;
            this.tests= [this._scriptTest];
        },

        _isSubform : function() {
            return true;
        },

        getInvalidObjects : function() {
            var list = new xfalib.script.XfaList();
            var sMessages = new Array();
            this._validate(sMessages);
            for ( var i = 0; i < sMessages.length; i++) {
                list._append(sMessages[i].ref);
            }
            return list;
        },

        _eventHandler : function(eventName) {
            var rValue = undefined;
            switch (eventName) {
                case "validate":
                    if(this.moEvents["validate"] && this.moEvents["validate"].length >0){
                        rValue = this.moEvents["validate"][0].execute(this, "validate");
                    }else
                        rValue = true;
                    break;
                case "$formpreSubmit":
                    rValue = this._preSubmitEventHandler();
                default:
                if (this.moEvents[eventName]) {
                    for ( var i = 0; i < this.moEvents[eventName].length; i++) {
                        this.moEvents[eventName][i].execute(this, eventName);
                    }
                }
            }
            return rValue;
        },

        _nullTest : function(value,sMessages) {
            return true;
        },

        _requireGetterSetter : function(oChild){
            if(oChild.className == "pageSet")
                return true;
            else
                return Subform._super._requireGetterSetter.call(this, oChild);
        },

        _postAddChild : function(oNode){
            if(oNode.instanceManager){
                // clear all cached contexts in EventContainerNode-s
                xfalib.runtime.xfa._clearAllMoContexts();

                this._xfa()._xfaTemplateCache.putModel(oNode, oNode.instanceManager._instanceTemplate());
                if(this.mEffectiveAccess){
                    oNode._calculateEffectiveAccess();
                }
                if(this.mEffectivePresence){
                    oNode._calculateEffectivePresence();
                }
                oNode._initialize();
                if (this.mbInitialized) {
                    // oNode.execEvent("initialize");
                    oNode.execCalculate();
                }

                // internalDispatchEvent(CollectionEventKind.ADD, oNode, index);

                // if (this.hasEventListener("change"))
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.CHILD_ADDED,this,"child",null,oNode);
                this.trigger(evnt.name,evnt);
            }
            else {
                //do nothing --- Let's face it You might call this function for other things besides subform e.x. items (see _getDisplayItems())
                Subform._super._postAddChild.call(this, oNode);
            }
        },

        _postRemoveChild : function(oChild){
            if(oChild.instanceManager){
                // clear all cached contexts in EventContainerNode-s
                xfalib.runtime.xfa._clearAllMoContexts();

                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.CHILD_REMOVED,this,"child", oChild, null);
                this.trigger(evnt.name,evnt);
            }
            else {
                Subform._super._postRemoveChild.call(this, oChild);
            }
        },

        playJsonForElement : function(elName, pJsonModel){
            if(elName == "instanceManager"){
                var newJChildren = _.filter(_.compact(pJsonModel.children), function (jChild) {
                    return this.xfaUtil().isRepeatabeEl(jChild._class) || jChild._class == "instanceManager";
                }, this);
                var oldMChildren = _.filter(this.moChildNodes, function(mChild){
                    return  this.xfaUtil().isRepeatabeEl(mChild.className)  || mChild.className == "instanceManager" ;
                }, this);

                var lastIM = null;
                _.each(oldMChildren, function(oldMChild){
                    //If oldMChild has any remaining IM then newJChildren must have at least one IM left
                    if(oldMChild.className == "instanceManager" && newJChildren[0]._class == "instanceManager"){
                        newJChildren.shift();
                    }
                    else if(oldMChild.className == "instanceManager" && this.xfaUtil().isRepeatabeEl(newJChildren[0]._class)){
                        while(this.xfaUtil().isRepeatabeEl(newJChildren[0]._class)){
                            var addedSf =lastIM.addInstance();
                            addedSf.playJson(newJChildren.shift());
                        }
                        newJChildren.shift(); // This must be instanceManager for next subform
                    }
                    else if(this.xfaUtil().isRepeatabeEl(oldMChild.className ) && (newJChildren[0] == null || newJChildren[0]._class == "instanceManager")){
                        lastIM.removeInstance(oldMChild.instanceIndex);
                    }
                    else {
                        //oldMChild.className == "subform" && newJChildren[0]._class == "subform"
                        oldMChild.playJson(newJChildren.shift());
                    }

                    if(oldMChild.className == "instanceManager" )
                        lastIM = oldMChild;

                }, this);
                while(newJChildren.length > 0){
                    var newJSF = newJChildren.shift();
                    var addedSF = lastIM.addInstance();
                    if (addedSF) {
                        addedSF.playJson(newJSF);
                    }
                }
                return true;
            } else if (this.xfaUtil().isRepeatabeEl(elName)) {
                return true;
            } else if (elName === "variables") {
                return true;  // LC-9508: don't playJson for variables
            } else {
                return Subform._super.playJsonForElement.call(this, elName, pJsonModel);
            }
        },

        _getXPathForUseNameBinding: function () {
            if(this.instanceManager._isRepeatable()) {
                var name = this.getAttribute("name");
                return name === "" ? null
                                   : {
                                        relative: true,
                                        bindRef: name + "[*]"
                                     };
            } else {
                return Subform._super._getXPathForUseNameBinding.apply(this);
            }
        },

        _playDataXML: function(xmlDocument, contextNode, currentBindRef) {
            if(this.parent.className === "form") {
                return Subform._super._playDataXML.apply(this,[xmlDocument,contextNode, currentBindRef]);
            }
            var xpath = this._getXpathFromBindRef(),
                relativeXPath, nodeIter, nodeList = [], node, count, instance;
            if(xpath == null) {
               Subform._super._playDataXML.apply(this,[xmlDocument,contextNode, currentBindRef]);
            } else {
                // The first instance will take care of the rest of the instances.
                if(this.instanceIndex === 0) {
                    nodeIter = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                    if (nodeIter != null) {
                        node = nodeIter.iterateNext();
                        while (node) {
                            nodeList.push(node);
                            node = nodeIter.iterateNext();
                        }
                        node = nodeList.shift();
                        count = 0;
                        while (node != null) {
                            if (count > this.instanceManager.count - 1) {
                                instance = this.instanceManager.addInstance();
                            } else {
                                instance = this.instanceManager.instances[count];
                            }
                            Subform._super._playDataXML.apply(instance, [xmlDocument, node, xpath]);
                            node = nodeList.shift();
                            count++;
                        }
                        while (count < this.instanceManager.count) {
                            if (this.instanceManager.count === this.instanceManager.min) {
                                instance = this.instanceManager.instances[count];
                                Subform._super._playDataXML.apply(instance, [xmlDocument, null, xpath]);
                                count++;
                            } else {
                                this.instanceManager.removeInstance(count);
                            }
                        }
                    }
                }
            }
        },

        /**
         * Generates the XML by appending the elements in the rootNode
         * @param rootNode The rootNode of the xml. Generally the element that maps to the root of the form
         * @param contextNode Current Node where to insert the elements in case of relative bindings
         */
        generateDataXML: function(rootNode, contextNode) {
            if(this.parent.className === "form") {
                return Subform._super.generateDataXML.apply(this,[rootNode,contextNode]);
            }
            var xpath = this._getXpathFromBindRef(),
                xmlUtils = xfalib.ut.XMLUtils,
                parentElement, element, childElement, childXPath, childXPathParts,
                childElementName, childElementIndex;
            if(xpath == null) {
                Subform._super.generateDataXML.apply(this,[rootNode,contextNode]);
            } else {
                element = xpath.relative === false ? rootNode : contextNode;
                parentElement = xmlUtils.createElementsFromXPath(xpath.bindRef, element, true);
                childXPath = _.last(xpath.bindRef.split("/"));
                childXPathParts = xmlUtils._getElementNameAndIndexFromXPathPart(childXPath);
                childElementName = childXPathParts.name;
                childElementIndex = childXPathParts.index;
                //TODO: * doesn't gaurantees that the element can be repeated in schema. But we have no choice for now
                if(childElementIndex === "*") {
                    if(this.instanceIndex === 0) {
                        // For repeatable subforms the first child does the processing for all the siblings

                        // cache all existing children
                        var existingInstances = parentElement.hasChildNodes() ? parentElement.childNodes : null;

                        // filter out current repeatable ones
                        if (!_.isEmpty(existingInstances)) {
                            existingInstances = _.filter(existingInstances, function (child) { return child.nodeName === childElementName; });
                        }

                        _.each(this.instanceManager.instances, function (instance) {
                            var index = instance.instanceIndex + 1,
                                childElement = xmlUtils.findOrCreateElement(childElementName + "[" + index + "]",
                                    parentElement);
                            Subform._super.generateDataXML.apply(instance,[rootNode, childElement]);
                        }, this);

                        if(!_.isEmpty(existingInstances)) {
                            // remove the left over ones, caused if one deletes an instance.
                            // since we are regenerating xml, no need to worry about order, remaining SFs will update their data from the xml's top elems
                            for(var i = this.instanceManager.count; i < existingInstances.length; ++i) {
                                parentElement.removeChild(existingInstances[i]);
                            }
                        }
                        // But this will have a side effect in case of any other repeatable subform mapping to the same xpath LC-3911518
                    }
                } else {
                    childElement = xmlUtils.findOrCreateElement(childElementName +"[" + childElementIndex + "]",
                        parentElement);
                    Subform._super.generateDataXML.apply(this,[rootNode, childElement]);
                }
            }
        },

        _getDataSomMap : function (dataSomMap) {
            if(!this.instanceManager || !this.instanceManager._isRepeatable()) {
                return Subform._super._getDataSomMap.apply(this,arguments)
            }
            return dataSomMap;
        },

        _restoreDataSomMap: function(map) {
            if(!this.instanceManager || !this.instanceManager._isRepeatable()) {
                Subform._super._restoreDataSomMap.apply(this,arguments)
            }
        },

        _preSubmitEventHandler: xfalib.script.Field.prototype._preSubmitEventHandler
    });

    Subform.defineProps({
        "locale": {
            get: function() {
                var obj = this;
                var locale;
                while(!locale && obj) {
                    locale = obj.jsonModel.locale;
                    obj = obj.parent;
                }
                locale = locale || "en-US"; //TODO: read from jsp
                return locale;
            }
        },

        "instanceIndex":
        {
            get : function() {
                return this.mnInstanceIndex;
            }
        },

        "instanceManager": {
            get: function() {
                return this._instanceManager;
            },
            resolve:true
        },

        "occur": {
            get: function() {
                return this.instanceManager.occur;
            },
            resolve:true
        },

        "pageSet": {
            get: function(){
                return this.getElement("pageSet", 0, true);
            }
        },

        "variables": {
            get : function() {
                return  this.getElement("variables",0);
            } ,
            set :function(value) {
                this.setElement(value,"variables");
            }
        }
    });

    Subform.addMixins([
        xfalib.script.mixin.AddAssist,
        xfalib.script.mixin.AddPresence,
        xfalib.script.mixin.AddXYWH,
        xfalib.script.mixin.AddFillColor,
        xfalib.script.mixin.AddBorder,
        xfalib.script.mixin.AddBorderColor,
        xfalib.script.mixin.AddBorderWidth,
        xfalib.script.mixin.AddPara,
        xfalib.script.mixin.AddMargin
    ]);

})(_,xfalib);
/**
 * @package xfalib.script.ContentArea
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the ContentArea Class required for XFA library
 * @version 0.0.1
 */

(function (_, xfalib) {
    /**
     * Creates a new ContentArea class
     *
     * @class The class represents a subform in the XFA Dom
     * @param {string}
     *            name the name of the node
     * @extends com.adobe.xfa.scripting.ContainerNode
     */
    var ContentArea = xfalib.script.ContentArea = xfalib.script.ContainerNode.extend({
        _computeJsonDiff: function (diff_level) {
            return xfalib.ut.XfaUtil.prototype.partialStripOrCall.call(this, diff_level, ContentArea._super._computeJsonDiff);
        }
    });

    ContentArea.addMixins([
        xfalib.script.mixin.AddXYWH
    ]);

})(_, xfalib);

/**
 * @package xfalib.script.PageArea
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the PageArea Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new PageArea class
     *
     * @class The class represents a subform in the XFA Dom
     * @param {string}
        *            name the name of the node
     * @extends com.adobe.xfa.scripting.ContainerNode
     */
    var PageArea = xfalib.script.PageArea = xfalib.script.EventContainerNode.extend({
        execEvent : function(eventName) {
            return undefined;
        },

        playJsonForElement: xfalib.script.Subform.prototype.playJsonForElement,

        _computeJsonDiff: function (diff_level) {
            return xfalib.ut.XfaUtil.prototype.partialStripOrCall.call(this, diff_level, PageArea._super._computeJsonDiff);
        }
    });

    PageArea.defineProps({
        "access" : {
            get : function() {  //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            }
        },


        "presence" : {
            get : function() { //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.presence, this._defaults.presence);
            }
        }
    });
})(_, xfalib);




/**
 * @package xfalib.script.PageSet
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the PageSet Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new PageSet class
     *
     * @class The class represents a subform in the XFA Dom
     * @param {string}
        *            name the name of the node
     * @extends com.adobe.xfa.scripting.ContainerNode
     */
    var PageSet = xfalib.script.PageSet = xfalib.script.EventContainerNode.extend({
        execEvent : function(eventName) {
            return undefined;
        },

        _computeJsonDiff: function (diff_level) {
            return xfalib.ut.XfaUtil.prototype.partialStripOrCall.call(this, diff_level, PageSet._super._computeJsonDiff);
        },

        playJsonForElement: function (elName, pJsonModel) {
            if(elName === "pageArea") { // LC-3642518 : allow data-merge on master page
                var newJChildren = _.filter(_.compact(pJsonModel.children), function (jChild) {
                    return jChild._class === "pageArea";
                }, this);
                var oldMChildren = _.filter(this.moChildNodes, function (mChild) {
                    return mChild.className === "pageArea";
                }, this);

                _.each(oldMChildren, function (oldMChild) {
                    var idPattern = new RegExp("^" + oldMChild.jsonModel.id + "(?:_ID)*$"); // look for an id value, followed by zero or more "_ID" suffixes
                    _.each(newJChildren, function (newJChild) {
                        if (oldMChild.name && oldMChild.name == newJChild.name && idPattern.test(newJChild.id)) { // match name as well as id, to account for mystery xtg master pg id gen logic
                            try {
                                oldMChild.playJson(newJChild); // may throw an exception, say for 0-instance fields on master pg. Say expected an inst.man but found null
                            } catch (exception) {
                                xfalib.runtime.xfa.Logger.error("xfa", "Exception during DataMerge on fields in master page. ",
                                                                [exception, oldMChild," PlayJSON on", newJChild]);
                            }
                        }
                    }, this);
                }, this);

                return true;
            } else {
                return PageSet._super.playJsonForElement.call(this, elName, pJsonModel);
            }
        }
    });

    PageSet.defineProps({
        "access" : {
            get : function() {  //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            }
        },

        "presence" : {
            get : function() { //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.presence, this._defaults.presence);
            }
        }

    });
})(_, xfalib);
/**
 * @fileOverview The file creates the SubformSet Class required for XFA library
 * @class The class represents a SubformSet in the XFA Dom
 * @version 0.0.1
 */
(function(_,xfalib){
    var SubformSet = xfalib.script.SubformSet = xfalib.script.Subform.extend({
        initialize: function() {
            SubformSet._super.initialize.call(this);
            this.tests = null;
        },

        execEvent : function(eventName) {
            return undefined;
        }

    });

    SubformSet.defineProps({
        "access": {
            get: function () {  //i am not sure how to make this property undefined so just removed setters for now
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            }

            //TODO : Add setter to delegate to children

        },

        "presence": {
            get: function () { //i am not sure how to make this property undefined so just removed setters for now
                return this.getOrElse(this.jsonModel.presence, this._defaults.presence);
            }

            //TODO : Add setter to delegate to children
        }

    });
})(_,xfalib);/**
 * @fileOverview The file creates the Area Class required for XFA library
 * @class The class represents a Area in the XFA Dom
 * @version 0.0.1
 */
(function(_,xfalib){
    var Area = xfalib.script.Area = xfalib.script.EventContainerNode.extend({
        execEvent : function(eventName) {
            return undefined;
        },

        playJsonForElement : xfalib.script.Subform.prototype.playJsonForElement

    });

    Area.defineProps({
        "access" : {
            get : function() {  //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.access, this._defaults.access);
            }
        },

        "presence" : {
            get : function() { //i am not sure how to make this property undefined so just removed setters
                return this.getOrElse(this.jsonModel.presence, this._defaults.presence);
            }
        }

    });

    Area.addMixins([
        xfalib.script.mixin.AddXYWH
    ]);

})(_,xfalib);/**
 * @fileOverview The file creates the Variables Class required for XFA library
 * @class The class represents a Variables in the XFA Dom
 * @version 0.0.1
 */
(function (_, xfalib) {
    var Variables = xfalib.script.Variables = xfalib.script.ContainerNode.extend({
        _initChildren: function () {
            var children = new Array();
            if (this.jsonModel.children) {
                var j = 0;
                for (var i = 0; i < this.jsonModel.children.length; i++) {
                    var child = this.jsonModel.children[i];
                    var childModel = xfalib.script.XfaModelRegistry.prototype.createNodeValue(child);
                    if (childModel) {
                        children[j++] = childModel;
                    }
                }
                this.children = children;
            }
        },

        _computeJsonDiff: function (diff_level) {
            // don't need variables for submission, but need them for replay on restoreFormState
            return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level === 2, Variables._super._computeJsonDiff, arguments);
        },

        scopeless: function () {
            return ((this.name || "").length == 0);
        },

        /**
         * Return the DataSOMMap after adding an entry in the map for the node. The entry contains the value of the node
         * along with its Data SOM. If there is no Data SOM then return the unmodified map
         * @param map
         * @private
         */
        _getDataSomMap: function (map) {
            return map;
        },

        /**
         * Update the value of the node with the value provided in the input map. The map contains the values of the fields
         * mapped with their DataSOM. The function is empty for all the nodes, except for Field, Subform and Area.
         * @param map
         * @private
         */
        _restoreDataSomMap : function (map) {

        }

    });

    Variables.defineProps({
        "presence": {
            get: function () { //i am not sure how to make this property undefined so just removed setters
                return undefined;
            },
            set: function () {
            }
        }

    });
})(_, xfalib);
/**
 * @package xfalib.script.Occur
 * @import xfalib.ut.Class
 * @fileOverview The file creates the Occur Class required by InstanceManager
 *               for XFA library
 * @version 0.0.1
 */


(function(_, xfalib){
    /**
     * Creates a new Occur object
     *
     * @class The class represents the Occur Object
     * @constructor
     * @param {number}
        *            initial Initial occurrence of the subform managed by parent
     *            InstanceManager
     * @param {number}
        *            max Maximum occurrence of the subform managed by parent
     *            InstanceManager
     * @param {number}
        *            min Minimum occurrence of the subform managed by parent
     *            InstanceManager
     * @property {number} initial Initial occurrence of the subform managed by
     *           parent InstanceManager
     * @property {number} max Maximum occurrence of the subform managed by parent
     *           InstanceManager
     * @property {number} min Minimum occurrence of the subform managed by parent
     *           InstanceManager
     */
    var Occur = xfalib.script.Occur = xfalib.ut.Class.extend({
        _defaults : {
            "min" : "1",
            "max" : "1",
            "initial" : "1"
        },
        msClassName: "occur"

    });

    Occur.defineProps({
        initial:{
            get: function() {
                return parseInt(this.getOrElse(this.jsonModel.initial, this._defaults.initial));
            }
        },

        min: {
            get: function() {
                return parseInt(this.getOrElse(this.jsonModel.min, this._defaults.min));
            },
            set: function(nMin) {
            	this.jsonModel.min = nMin + "";
            }
        },

        max: {
            get: function() {
                return parseInt(this.getOrElse(this.jsonModel.max, this.min));
            },
            set: function(nMax) {
            	this.jsonModel.max = nMax + "";
            }
        },

        playJson : function(pJsonModel) {

        }

    })
})(_, xfalib);
/**
 * @package xfalib.script.InstanceManager
 * @import xfalib.script.Node
 * @import xfalib.script.Occur
 * @fileOverview The file creates the InstanceManager Class required for XFA
 *               library
 * @class The class represents a Instance Manager to manage multiple instance of
 *        subforms
 * @version 0.0.1
 */

(function (_, xfalib) {

    var InstanceManager = xfalib.script.InstanceManager = xfalib.script.Node.extend(
        {
            msClassName: "instanceManager",
            initialize: function () {
                InstanceManager._super.initialize.call(this);
                this._occur = new xfalib.script.Occur({"jsonModel": this.jsonModel});
                this.moChildrenCreated = [];
                this.mnCurrent = 0;
                this.mbStandalone = false;
            },

            _instanceTemplate: function () {
                var parent = this.parent;
                if (this._templateRef() == null || parent == null || parent._templateRef() == null || parent._templateRef().children == null)
                    return null;
                var tmpltParent = parent._templateRef();
                var imIndex = tmpltParent.children.indexOf(this._templateRef());
                if (imIndex < 0 || tmpltParent.children.length < imIndex + 2)
                    return null;
                else {
                    return tmpltParent.children[imIndex + 1];
                }
            },

            _isRepeatable: function () {
                var max;
                return ((max = +this.max) < 0 || +this.min < max);
            },

            _isInstanceManager: function () {
                return true;
            },

            /**
             * @private
             *
             * Manage a child instance that was created.
             *
             * @param oCreatedChild
             *        the child to be managed.
             */


            _manageChild: function (oCreatedChild, nIndex) {
                oCreatedChild._instanceManager = this;
                if (this.moChildrenCreated.length >= 1) {
                    oCreatedChild = this._updateDataSomForRepeatedRows(oCreatedChild);
                }
                if (nIndex === undefined) {
                    this.moChildrenCreated.splice(this.mnCurrent, 0, oCreatedChild);
                    oCreatedChild.mnInstanceIndex = this.mnCurrent++;
                }
                else {
                    this.moChildrenCreated.splice(nIndex, 0, oCreatedChild);
                    oCreatedChild.mnInstanceIndex = nIndex;
                    this.mnCurrent++;
                    for (var i = nIndex + 1; i < this.moChildrenCreated.length; i++)
                        this.moChildrenCreated[i].mnInstanceIndex = i;
                }
            },

            _replaceLastOccurrenceOfSubString: function(string, find, replace) {
                var lastIndex = string.lastIndexOf(find);
                if (lastIndex === -1) {
                    return string;
                }
                var beginString = string.substring(0, lastIndex);
                var endString = string.substring(lastIndex + find.length);
                return beginString + replace + endString;
            },

            _updateDataSomForRepeatedRows: function(oCreatedChild) {
                var currentDataSom = oCreatedChild.jsonModel.extras.dataSom;
                var lengthOfChildCreated = this.moChildrenCreated.length;
                var lastAddedRowDataSom = this.moChildrenCreated[lengthOfChildCreated - 1].jsonModel.extras.dataSom;
                if (currentDataSom && lastAddedRowDataSom) {
                    var indexToUpdate = currentDataSom.substring(currentDataSom.lastIndexOf("[") + 1, currentDataSom.lastIndexOf("]"));
                    var updatedDataSomIndex = lastAddedRowDataSom.substring(lastAddedRowDataSom.lastIndexOf("[") + 1, lastAddedRowDataSom.lastIndexOf("]"));
                    updatedDataSomIndex++;
                    var updatedDataSom = this._replaceLastOccurrenceOfSubString(currentDataSom, indexToUpdate, updatedDataSomIndex);
                    oCreatedChild.jsonModel.extras.dataSom = updatedDataSom;
                    oCreatedChild.resolveNode("#extras.FS_EXTRAS.FS_DATA_SOM").value = updatedDataSom;
                }
                return oCreatedChild;
            },

            _computeJsonDiff: function (diff_level) {
                //we don't need InstanceManager for final submission if there is only one instance, and it's not a repeatable SF
                // but need it for maintaining hierarchy in restoreFormState
                return xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, diff_level === 2 && (!this._isRepeatable() && this.moChildrenCreated.length <= 1), InstanceManager._super._computeJsonDiff, arguments);
            },

            /*
             * add an instance of the repeatable subform.
             */
            addInstance: function () {
                return this._insertInstance();
            },

            _insertInstance: function (nIndex, oChildAdded) {
                if ((+this.max >= 0) && (+this.max == this.count)) //TODO : discuss whether to use private variables or not
                    return null;
                if (nIndex !== undefined && nIndex > +this.count)
                    return null;

                if (oChildAdded === undefined) {
                    var sfTemplate = this._instanceTemplate();
                    //
                    // needs to add an instance to the model
                    //
                    if (sfTemplate == null)
                        return null;
                    var clonedJson = {};
                    var uniquePrefix = this.xfaUtil().generateUID();
                    this.copyObject(sfTemplate, clonedJson,
                        {
                            exceptions: ["htmlId"],
                            transformMaps: {
                                "dataId": function (srcValue, options) {
                                    return uniquePrefix + "_" + srcValue;
                                }
                            }
                        }
                    );
                    oChildAdded = xfalib.script.XfaModelRegistry.prototype.createModel(clonedJson);
                }
                if (oChildAdded != null) {
                    //
                    // first add the child to the list of managed children
                    //
                    oChildAdded._newChild = true
                    this._manageChild(oChildAdded, nIndex);
                    //
                    //TODO: If not standalone mode, add the new item to the parent container as well. Understanding standalone mode
                    //
                    if (this.mbStandalone == true) {
                        if (nIndex !== undefined)
                            oChildAdded.index = nIndex;
                        else
                            oChildAdded.index = this.mnCurrent;
                        oChildAdded.parent = this.parent;
                    } else {
                        var oParentContainer = this.parent;
                        if (oParentContainer != null) {
                            if (this.mnCurrent > 1 && nIndex!==0) {
                                //
                                // If we already had children get the index of first
                                // child in the parent container
                                //
                                nIndex = nIndex !== undefined ? nIndex : this.mnCurrent - 1;
                                var nInsertionIndex = oParentContainer
                                    ._getChildIndex(this.moChildrenCreated[nIndex - 1]);
                                nInsertionIndex++;
                                oParentContainer._addChildAt(oChildAdded,
                                    nInsertionIndex);
                            } else {
                                //
                                // If this is the first child, add it just after the
                                // instance manager
                                //
                                oParentContainer._addChildAt(oChildAdded,
                                        oParentContainer._getChildIndex(this) + 1);
                            }

                        }
                    }
                    if (_.contains(['INITIALIZED', 'INITIALIZING'], this._xfa()._modelInitialize)) {
                        try {
                            oChildAdded.execInitialize();
                            // if the instance being added is the first one, we need to run execCalculate on the form to get dependents
                            // for the instance being added.
                            if (this.count == 1) {
                                this._xfa().form.execCalculate();
                            } else {
                                var firstInstance = this.instances[0];
                                this._triggerCalculateForDependantFields(firstInstance);
                                oChildAdded.execCalculate();
                            }
                        } catch (ex) {
                            this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-013"], ["addInstance"]);
                        }
                    }
                    return oChildAdded;
                }
                return null;
            },

            insertInstance: function (nIndex) {
                return this._insertInstance(nIndex);
            },


            moveInstance: function (sIndex, dIndex) {
                if ((+this.max >= 0) && dIndex >= +this.count || sIndex >= +this.count || sIndex == dIndex) //TODO : discuss whether to use private variables or not
                    return null;
                var tIndex,
                    oParentContainer = this.parent,
                    oChild = this.moChildrenCreated[sIndex],
                    tsIndex = dIndex < sIndex ? sIndex + 1 : sIndex,
                    tdIndex = dIndex > sIndex ? dIndex + 1 : dIndex;
                this.max++;
                var newChild = this._insertInstance(tdIndex);
                this.max--;
                newChild.playJson(oChild.jsonModel);
                if (oParentContainer != null) {
                    var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.CHILD_MOVED, oParentContainer, "child", null, null);
                    oParentContainer.trigger(evnt.name, evnt);
                }
                this.removeInstance(tsIndex);
            },


            /*
             * add an instance of the repeatable subform.
             */
            removeInstance: function (index) {
                //
                // don't remove any more than the minimum
                //
                if (this.count == 0 || this.min == this.count)
                    return;

                if (index >= +this.count)
                    return;
                //
                // needs to remove an instance to the model
                //
                var firstInstance = this.instances[0];
                var oChild = this.moChildrenCreated[index];
                this.moChildrenCreated.splice(index, 1);
                this.mnCurrent--;
                for (var i = index; i < this.moChildrenCreated.length; i++)
                    this.moChildrenCreated[i].mnInstanceIndex = i;
                var parent = oChild.parent;
                parent._removeChild(oChild);

                if (_.contains(['INITIALIZED', 'INITIALIZING'], this._xfa()._modelInitialize)) {
                    try {
                        this._triggerCalculateForDependantFields(firstInstance);
                    } catch (ex) {
                        this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-013"], ["removeInstance"]);
                    }
                }
            },

            /*
             * empty function since there is no data associated with IM
             */
            resetData: function () {

            },

            setInstances: function (num) {
                this.count = num;
            },
            /*
             *
             */
            getNaked: function (nIndex, createGetterSetter, Obj, scope) {
                if (this.getAttribute("name").length > 0 && this.getAttribute("name") != "_")
                    InstanceManager._super.getNaked.apply(this, arguments);
            },

            playJson: function (pJsonModel) {

            },
            /*
             * Trigger calculate event for only the dependent fields in the repeatable subform
             */
            _triggerCalculateForDependantFields : function (model) {
                var modelChildren = model.moChildNodes;
                _.each(modelChildren, function(modelChild){
                    // trigger calculate for the dependents of the field and exclusion group
                    if (modelChild._isField() || modelChild._isExclusionGroup()) {
                        var dependantNodes = modelChild.dependant;
                        _.each(dependantNodes, function(dependantNode){
                            dependantNode.execEvent("calculate");
                        });
                    } else if (modelChild._isEventNode()) {
                        this._triggerCalculateForDependantFields(modelChild);
                    }
                },this);
            }
        }
    );
    InstanceManager.defineProps({
        "min": {
            get: function () {
                return this.occur.min + "";
            },
            set: function (nMin) {
                this.occur.min = nMin;
            }
        },
        "max": {
            get: function () {
                return this.occur.max + "";
            },
            set: function (nMax) {
                this.occur.max = nMax;
            }
        },

        "occur": {
            get: function () {
                return this._occur;
            }
        },
        // This API is used in adaptive form
        "instances": {
            get: function() {
                return _.extend([], this.moChildrenCreated);
            }
        },

        "count": {
            get: function () {
                return this.moChildrenCreated.length + "";
            },
            set: function (value) {
                if (value == parseInt(value))
                    value = parseInt(value);
                else return;
                var count = +this.count,
                    tvalue = Math.abs(value - count),
                    max = +this.max,
                    min = +this.min;
                //Bug#3544368 value > max condition will only hold if max is positive (if max == -1
                // there is no limit on the upper count )
                if ((max > 0 && value > max) || value < min || value == count)
                    return;
                if (value > count) {
                    for (var i = 0; i < tvalue; i++)
                        this._insertInstance();
                }
                if (value < count) {
                    for (var i = 0; i < tvalue; i++)
                        this.removeInstance(--count);
                }
            }
        }
    })
})(_, xfalib);

/**
 * @package xfalib.script.ExclusionGroup
 * @import xfalib.script.ContainerNode
 * @fileOverview The file creates the ExclusionGroup Class required for XFA
 *               library
 * @version 0.0.1
 */

(function(_, xfalib){
    /**
     * Creates a new ExclusionGroup class
     *
     * @class The class represents a ExclusionGroup in the XFA Dom
     * @param {string}
        *            name the name of the node
     * @extends com.adobe.xfa.scripting.ContainerNode
     */
    var ExclusionGroup = xfalib.script.ExclusionGroup = xfalib.script.EventContainerNode.extend({

        initialize : function(){
            ExclusionGroup._super.initialize.call(this);
            this.tests= [this._nullTest,this._scriptTest];
            var dataId = this.getOrElse(this, "jsonModel.extras.dataId", null);
            if (dataId) {
                this._xfa().createDataNode(dataId, this);
            }
        },

        _getOnChild: function(otherChild) {
            return _.find(this.moChildNodes, function(child) {
                 return child.className == "field" && child.selectedIndex == 0 && child != otherChild
            })
        },

        _eventHandler : function(eventName) {
            var rValue = undefined;
            switch(eventName) {
                case "calculate":
                    if(this.moEvents["calculate"] && this.moEvents["calculate"].length >0){
                        rValue = this.moEvents["calculate"][0].execute(this, "calculate");
                    }
                    break;
                case "validate":
                    if(this.moEvents["validate"] && this.moEvents["validate"].length >0){
                        rValue = this.moEvents["validate"][0].execute(this, "validate");
                    }else
                        rValue = true;
                    break;
                case "$formpreSubmit":
                    rValue = this._preSubmitEventHandler();
                    break;
                default:
                    if (this.moEvents[eventName]) {
                        for ( var i = 0; i < this.moEvents[eventName].length; i++) {
                            this.moEvents[eventName][i].execute(this, eventName);
                        }
                    }
//                    ExclusionGroup._super._eventHandler.call(this, eventName);  //TODO: Why this is required?
            }
            return rValue
        },

        _handleSelectChild : function(child) {
            var oldVal = this.rawValue,
                evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                                                                this,"ClearError",null, null),
                onChild = this._getOnChild(child);

            this.trigger(evnt.name,evnt);

            if (child.selectedIndex == 0) {
                if(onChild)
                    onChild.setItemState(0,false);
                this._handleDependants();
                // trigger model change event for rawValue, so that value can be propogated to rest of the fields with same dataId
                var evntRawValue = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED,
                                                                    this,"rawValue",this.rawValue, this.rawValue);
                this.trigger(evntRawValue.name,evntRawValue);
            } else if (child._matches(onChild)) {
                 this._handleDependants();
            }
        },

        selectedMember : function() {
            var currentNode = this._xfa().moCalculateEventNode;
            if (currentNode != null) {
                this.addDependant(currentNode);
            }
            return this._getOnChild();
        },

        _isExclusionGroup : function() {
            return true;
        },

        _getValue : function() {
            var onChild = this._getOnChild()
            return onChild ? onChild._getValue() : null;
        },

        _nullTest : function(sMessages) {
            var valid = true;
            var value = this._getValue();
            if (value == null && this.mandatory != "disabled") {
                this._mFailedValTest = "nullTest";
                this._mFailedValLevel = this.mandatory;
                this._errorText = this.mandatoryMessage;
                this._addMessage(sMessages, this._errorText, this._mFailedValLevel);
                valid = false;
            }
            return valid;
        },

        _getElementsFromXpath: xfalib.script.Field.prototype._getElementsFromXpath,

        _preSubmitEventHandler: xfalib.script.Field.prototype._preSubmitEventHandler,

        /**
         * Exclusion Group can have two types of prefill xml. Long format and short format . In case of Long format,
         * the value of each of  the children of exclusion group is present and hence we need to iterate the children to
         * prefill the value. For short format the textContent is the value of the Exclusion Group
         *
         * The difference between the short and Long format is that in short Format, there are no children of Exclusion
         * Group in xml.
         * @param xmlDocument
         * @param contextNode
         * @param currentBindRef
         * @private
         */
        _playDataXML: function(xmlDocument, contextNode, currentBindRef) {
            var xpath = this._getXpathFromBindRef(),
                nodeIter;
            if(xpath != null) {
                nodeIter = this._getElementsFromXpath(xpath, contextNode, xmlDocument);
                if(nodeIter != null) {
                    var node = nodeIter.iterateNext();
                    if(node != null) {
                        // node has further element childs then iterate over them otherwise set the content as its rawValue
                        if(node.childElementCount > 0) {
                            ExclusionGroup._super._playDataXML.apply(this, [xmlDocument, node, currentBindRef]);
                        } else {
                            this.rawValue = node.textContent;
                        }
                    }
                } else {
                    this._resetData();
                }
            }
        },

        generateDataXML: xfalib.script.Field.prototype.generateDataXML,

        _appendValueInXMLElement: xfalib.script.Field.prototype._appendValueInXMLElement
    });

    ExclusionGroup.defineProps({
        "rawValue" : {
            get : function() {
                var currentNode = this._xfa().moCalculateEventNode;
                if (currentNode != null) {
                    this.addDependant(currentNode);
                    // The children should not register the
                    // calculateNode as dependent on them, else the
                    // calculate event for calculateNode will be called
                    // multiple times.
                    this._xfa()._popCalculateEventNode();
                }

                var val = this._getValue();

                if (currentNode != null)
                    this._xfa()._pushCalculateEventNode(currentNode);

                return val;
            },
            set : function(oValue) {
            	var sMessages = new Array(),
                    onChild = this._getOnChild(),
                    oldVal = onChild ? onChild._getValue() : null

                oValue = this.validateInput(oValue, "string");
                if (oldVal === oValue)
                    return;
                if (onChild) {
                    onChild.setItemState(0, false);
                }
                onChild = _.find(this.moChildNodes, function(child) {
                                    return child.className == "field" &&
                                           child.getOrElse(child.getSaveItem(0), child.getDisplayItem(0)) == oValue
                                })
                if (onChild)
                    onChild.rawValue = oValue;
                this._handleDependants();
                this._xfa().queueValidateEvent(this);
            }
        },

        "mandatory" : {
            get : function() {
                return this.getOrElse(this.validate.nullTest, this._defaults.validate.nullTest);
            },
            set: function (value) {
                if(this.validate){
                    this.validate.nullTest = value;
                }
            }
        },

        "members" : {
            get : function() {
                var list = new xfalib.script.XfaList();
                this.moChildNodes.filter(function(elem) {
                    return elem._isField();
                }).map(function(elem1){
                    list._append(elem1);
                });
                return list;
            }
        },

        "isNull":{
            get : function() {
               if(this._getValue() != null)return false;
               else return true;
            }
        },

        "mandatoryMessage" : {
            get : function() {
                return xfalib.ut.XfaUtil.prototype._getMandatoryMessage(this);
            },
            set: function (val) {
                var nodes = this.validate.message.nodes;
                if (nodes.namedItem("nullTest") === null) {
                    var node = this._xfa().form.createNode("text", "nullTest");
                    nodes.append(node);
                }
                this.validate.message.nullTest.value = val;
                this.execValidate();
            }
        }
    });

    ExclusionGroup.addMixins([
        xfalib.script.mixin.AddAssist,
        xfalib.script.mixin.AddCaption,
        xfalib.script.mixin.AddPresence,
        xfalib.script.mixin.AddXYWH,
        xfalib.script.mixin.AddFillColor,
        xfalib.script.mixin.AddBorder,
        xfalib.script.mixin.AddBorderColor,
        xfalib.script.mixin.AddPara,
        xfalib.script.mixin.AddMargin
    ]);

})(_, xfalib);
/**
 * @package xfalib.script.Model
 * @import xfalib.script.Node
 */

(function(_, xfalib){
    var Model = xfalib.script.Model = xfalib.script.Element.extend({
        msClassName: "model",

        createNode : function(sClassName,sName,sNamespace) {    //TODO: looks incomplete
            sName = (typeof sName != 'undefined')?sName:"";
            sNamespace = (typeof sNamespace != 'undefined')?sNamespace:"";
            var jsonModel = {};
            jsonModel._class = sClassName;
            jsonModel.name = sName;
            var node = xfalib.script.XfaModelRegistry.prototype.createModel(jsonModel);
            return node;
        }
    });
})(_, xfalib);

/**
 * @package xfalib.script.Form
 * @import xfalib.script.ContainerNode
 */

(function (_, xfalib) {
    /**
     * @class
     * <p>
     * The Form class is the implementation of the top level XFA form object.
     * </p>
     *
     * <p>
     * The form object is accessed from the xfa object as xfa.form
     * </p>
     *
     */
    var Form = xfalib.script.Form = xfalib.script.EventContainerNode.extend({
        _getRootSubform: function () {
            return this.children[0];
        },

        _initialize: function () {
            this._xfa()._modelInitialize = 'INITIALIZING';
            var rootSubform = this._getRootSubform();
            rootSubform._initialize();
            //
            // Call all initialization then
            // calculations
            // scripts to execute
            //
            var pgSets = rootSubform.resolveNodes("#pageSet[*]");
            function execOnPgSets (execFuncname) {
                for(var i=0; i < pgSets.length; ++i) {
                    pgSets.item(i)[execFuncname]();
                }
            }

            rootSubform.execFormReady();
            execOnPgSets("execFormReady");
            rootSubform.execInitialize();
            execOnPgSets("execInitialize");
            rootSubform.execLayoutReady();
            execOnPgSets("execLayoutReady");
            rootSubform.execCalculate();
            this._xfa()._modelInitialize = 'INITIALIZED';
        },

        playJson: function (pJsonModel) {
            this._getRootSubform().playJson(pJsonModel.children[0]);
        },

        /**
         * @private
         * @function indicate that this is a Form node (~~).
         */
        _isForm: function () {
            return true;
        },

        execCalculate: function () {
            return this._getRootSubform().execCalculate();
        },

        execInitialize: function () {
            this._getRootSubform().execInitialize();
        },

        execFormReady: function () {
            this._getRootSubform().execFormReady();
        },

        execLayoutReady: function () {
            this._getRootSubform().execLayoutReady();
        },

        execValidate: function () {
            return this._getRootSubform().execValidate();
        },

        execPreSubmit: function () {
            return this._getRootSubform().execPreSubmit();
        },
        /**
         * remerge the data with the form model
         */
        remerge: function () {
            this._getRootSubform()._bind();
        },

        /**
         * recalculate this form model
         */
        recalculate: function (bool) {
            var xf = this._xfa();
            if (xf.host.calculationsEnabled) {
                if (xf.calculateRunning)
                    return;
                if (bool) {
                    this.execCalculate();
                    this.execFormReady();
                } else {
                    xf.runCalcs()
                }
            }
        },

        _computeJsonDiff: function (diff_level) {
            var diff = Form._super._computeJsonDiff.call(this, diff_level);
            diff.jsonDifference["versionNS"] = this.jsonModel["versionNS"];
            return { "changed": true,
                "jsonDifference": diff.jsonDifference
            };
        },

        createNode: xfalib.script.Model.prototype.createNode

    });
})(_, xfalib);
/**
 * @package xfalib.script.Host
 * @import xfalib.script.Node
 * @fileOverview The file creates the Host Class required for XFA library
 * @version 0.0.1
 */

(function(_, xfalib, $){
    /**
     * @class The class represents the Host Object
     * @extends com.adobe.xfa.scripting.Node
     * @property {string} appType the application type of the host
     * @property {number} currentPage Page number of the form that is being
     *           displayed
     * @property {number} numPages total number of pages in the form
     * @property {name} name name of the application
     * @property {number} platform OS platform on which the application is running
     * @property {number} title title of the document
     * @property {number} version version number of the current application
     */
    var Host = xfalib.script.Host = xfalib.script.Node.extend({
        msClassName: "hostPseudoModel",
        initialize : function(){
            Host._super.initialize.call(this);
            this.jsonModel.name = "";
            this.mPageNumber = 0;
            this.pagingManager = null ;
            this.mCalculationsEnabled = true;
            this.mValidataionsEnabled = true;
            this.mNumPages = "";
            this.dataBrowser = [
                {
                    string: navigator.userAgent,
                    subString: "Chrome",
                    identity: "Chrome"
                },
                {
                    string: navigator.vendor,
                    subString: "Apple",
                    identity: "Safari",
                    versionSearch: "Version"
                },
                {
                    prop: window.opera,
                    identity: "Opera",
                    versionSearch: "Version"
                },
                {
                    string: navigator.userAgent,
                    subString: "Firefox",
                    identity: "Firefox"
                },
                {		// for newer Netscapes (6+)
                    string: navigator.userAgent,
                    subString: "Netscape",
                    identity: "Netscape"
                },
                {
                    string: navigator.userAgent,
                    subString: "MSIE",
                    identity: "Internet Explorer",
                    versionSearch: "MSIE"
                },
                {
                    string: navigator.userAgent,
                    subString: "Gecko",
                    identity: "Mozilla",
                    versionSearch: "rv"
                },
                { 		// for older Netscapes (4-)
                    string: navigator.userAgent,
                    subString: "Mozilla",
                    identity: "Netscape",
                    versionSearch: "Mozilla"
                }
            ];
        },

        _searchVersion : function(data,srch) {
            var index = data.indexOf(srch);
            if (index == -1) return;
            var spcIndex = data.indexOf(" ",index);
            if(spcIndex == -1)
                return data.substring(index+srch.length+1);
            return data.substring(index+srch.length+1,spcIndex);
        },

        _browserDetect : function() {
            var data = this.dataBrowser;
            for (var i=0;i<data.length;i++)	{
                var dataString = data[i].string;
                var dataProp = data[i].prop;
                var versionSearchString = data[i].versionSearch || data[i].identity;
                var version = this._searchVersion(navigator.userAgent,versionSearchString) || this._searchVersion(navigator.appVersion,versionSearchString) || "an unknown version";
                if (dataString) {
                    if (dataString.indexOf(data[i].subString) != -1)
                        return data[i].identity+" "+version;
                }
                else if (dataProp)
                    return data[i].identity+" "+version;
            }
        },

        /**
         * The function displays a dialog box on the screen. <br />
         * <b>TO DO</b><br />
         * <ul>
         * <li> The function doesn't supports icons as of now. Needs adding support for
         * that.</li>
         * <li> The dialog uses the default styling (provided by google). Need to change
         * that too. </li>
         * </ul>
         *
         * @function
         * @param {string}
            *            message The message to display
         * @param {string}
            *            title The title to appear in the dialog's window title
         * @param {number}
            *            type The icon to display: '0' (Error (default)), '1' (Warning),
         *            '2' (Question), and '3' (Status).
         * @param {number}
            *            buttons The buttons to display: '0' (OK (default)), '1' (OK,
         *            Cancel), '2' (Yes, No), and '3' (Yes, No, Cancel).
         */
        messageBox : function(message, title, type, buttons) {
            return (this._messageBox(message,title,type,buttons,null));
        },

        _messageBox : function(message, title, type, buttons,callback) {
            title = title || "";
            buttons = buttons || 0;
            var img =["Error","Warning","Question","Status"];
            var imgType = "";
            if(type!=undefined)
                imgType =  "[ " + img[type] + " ]  ";
            message = imgType  +  title + "\n\r" + message ;

            switch (buttons) {
                case 0:
                    alert(message);
                    return 1 ;
                case 1:
                    var a = confirm(message);
                    if(a==true)
                        return 1;
                    else return 2;
                case 2:
                    var a = confirm(message);
                    this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-009"]) ;
                    if(a==true)
                        return 4;
                    else return 3;

                case 3:
                    this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-010"]);
                    return 0;
            }
        },

        /**
         * The function displays the next page of the document (if one exists)
         *
         * @function
         */
        pageDown : function() {
            if (this.currentPage != this.numPages -1 ) {
                if(this.pagingManager)
                    this.pagingManager.pageDown();
            }
        },

        /**
         * The function displays the previous page of the document (if one exists)
         *
         * @function
         */
        pageUp : function() {
            if (this.currentPage != 0)  {
                var prevPage = this.currentPage - 1;
                var a = $($(".page")[prevPage])  ;
                window.scrollTo(0,a.offset().top) ;
            }
        },

        gotoURL: function(url, bNewFrame) {
            /*if(!$("a#gotourl").length)
                $("<a id='gotourl'></a>").appendTo('body');
            $("a#gotourl").attr("href",url)[0].click();
            //$("a").click();     */
            if(url.search("http") == -1)
                url = "http://" + url ;
            if(bNewFrame != true) {
                window.open(url) ;
            }
            else
                window.location = url;
        },

        resetData : function() {
            if(arguments.length)
                _.each(arguments,function(som) {
                    var node = this._xfa().resolveNode(som);
                    if(node)
                        node._resetData();
                },this)
            else {
                this._xfa().form._resetData();
            }
        },

        setFocus : function(som) {
            if(navigator.userAgent.match(/iPad/i) != null && this._xfa().moContextScriptEvent == 'change') {
            // LC-4663 : setFocus was shifting focus, before keypress was visible in browser.
            // Currently iPad doesnt support calling focus() from within setTimeout, so disabling the functionality.
                this._setFocus(som); // don't queue focus events, fire it immediately
            } else {
                this._xfa().queueFocusEvent(this, som);
            }
        },

         _setFocus : function(som) {
                    var node = som;
                    if(typeof som == "string")
                        node = this._xfa().resolveNode(som);
                    if(node != null){
                       if(this.pagingManager){
                            if(navigator.userAgent.match(/iPad/i) != null && this._xfa().moContextScriptEvent == 'change') {
                                this.pagingManager._makePageForHtmlId(node.htmlId); // LC-4663 : just render, not setFocus
                            } else {
                                this.pagingManager._makePageForHtmlId(node.htmlId,node._setFocus,node);  // for all other events set the focus
                            }
                        }
                    }
                    return node;
        },

         getFocus : function() {
                          if(xfalib.view.FieldView.prototype.currentFocus)
                            return(xfalib.view.FieldView.prototype.currentFocus.model);
                          else
                            return null;
                        } ,

        playDataXml: function (xmlDocument) {
            var rootElement;
            if(_.isUndefined(document.evaluate)) {
                // need to do it here since XPathResult is also undefined in IE
                wgxpath.install();
            }
            if(_.isString(xmlDocument)) {
                this._xfa().Logger.info("xfa", "xmlDocument is of type string. converting it to document");
                xmlDocument = $.parseXML(xmlDocument);
            }
            rootElement = xfalib.ut.XMLUtils.getXFARootFormElementFromXML(xmlDocument);
            this._xfa().form._playDataXML(rootElement, rootElement, "");
        },

        playJson : function(xfaJsonModel) {
            var formDom =  _.find(xfaJsonModel.children,
                function(child){
                    return child._class == "form";
                }
            );
            this._xfa().form.playJson(formDom);
            var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.FORM_MODEL_REFRESH,
                this,"jsonModel",null,this._xfa().form.jsonModel);
            this.trigger(evnt.name,evnt);
        },

        runServerScript : function(options) {
            options = options|| {};
            var xfaDiff;
            if (window.FD && window.FD.isToggleEnabled("FT_FORMS-14224")) {
                xfaDiff = this._xfa()._computeJsonDiff(3).jsonDifference;
            } else {
                xfaDiff = this._xfa()._computeJsonDiff(0).jsonDifference;
            }
            var xfaDomString = JSON.stringify(xfaDiff);
           //clone the object to avoid polluting the context
            var params = _.extend({
                    formDom: xfaDomString,
                    packet: 'form'
                },
                options,
                xfalib.runtime.renderContext);

            var serverScriptSuccessHandler = function(result){
                this.playJson(result); //result will be a JSON object so just play it.
            };

            if(options.contextSom && options.activity)
            {
                var that = this;
                window.formBridge._invokeAtServer({
                    data: params,
                    success:_.bind(serverScriptSuccessHandler,this),
                    error: function(xhr,txtStatus,errorThrown) {
                        var msg
                        switch(xhr.status) {
                            case 0:
                                msg = xfalib.locale.LogMessages["ALC-FRM-901-008"];
                                that._xfa().Logger.error("xfa", msg + " " + xhr.statusText);
                                break;
                            default:
                                msg = xfalib.locale.LogMessages["ALC-FRM-901-001"];
                                that._xfa().Logger.error("xfa", msg + " " + xhr.statusText);
                                break;
                        }
                        that.messageBox(msg);
                    }
                });
            }
        },

        _validate : function(options) {
            var _options = options || {},
                valMessages = _options.valMessages || [];
            var valid = this._xfa().form._validate(valMessages);
            if(valid)
                return true;

            var errors = "";
            var warnings = "";

            for(var i=0; i < valMessages.length; i++)
            {
                var msg = null;
                if(msg = valMessages[i])
                {
                    if(msg.severity == "error") {
                        errors = errors + msg.message + "\r\n";
                    }
                    if(msg.severity == "warning"){
                        warnings = warnings + msg.message + "\r\n";
                    }
                }
            }
            if(errors)
            {
                var that = this;
                var msg = "  The form could not be submitted because "+valMessages.length +" errors were found"
                if($("#wb-main-in").length){
                    if(!$("#xfa-errorMessages").length){
                        $("#wb-main-in").prepend("<div id ='xfa-errorMessages'></div>");
                    }
                    $("#xfa-errorMessages").empty().text(msg).append("<ul id='xfa-errorList'></ul>");
                    _.each(valMessages,function(elem) {
                        $("<a></a>").appendTo($("<li></li>").appendTo('#xfa-errorList'))
                                         .text(elem.message)
                                          .click(
                                                function() {
                                                    return that.setFocus(elem.ref);
                                                });
                    })
                    if(valMessages.length ==0)
                        $("#xfa-errorMessages").hide();
                    else
                        $("#xfa-errorMessages").show();
                }
                this.setFocus(valMessages[0].ref);
                return false;
            }
            else if(warnings)
            {
                this.messageBox(warnings, xfalib.locale.Strings.warning, 1, 0);   //TODO :Should  be ok/cancel
                return true;
            }
        },

        /**
         * Helper function for currentDateTime
         *
         * @function
         */
        _padzero : function(n) {
            return n < 10 ? '0' + n : n;
        },

        /**
         * Helper function for currentDateTime
         *
         * @function
         */
        _pad2zeros : function(n) {
            if (n < 100) {
                n = '0' + n;
            }
            if (n < 10) {
                n = '0' + n;
            }
            return n;
        },

        /**
        * The function Returns current date and time in [m]m/[d]d/yy [H]H:[M]M (A|P)M format
        *
        * @function
        */
        currentDateTime : function() {
            var now = new Date(),
                    curYear = now.getFullYear() +'',
                    curMonth = now.getMonth()+1 +'',
                    curDate = now.getDate() +'',
                    curHour = now.getHours() +'',
                    curMin = now.getMinutes() +'',
                    curSec = now.getSeconds() +'';

            return (curYear + this._padzero(curMonth) + this._padzero(curDate) + 'T' +
                    this._padzero(curHour) + this._padzero(curMin) + this._padzero(curSec));
        },

        /**
         * Helper function for currentDateTime
         *
         * @function
         */
        _toISOString : function(d) {
            return d.getUTCFullYear() + '-' +  this._padzero(d.getUTCMonth() + 1) + '-' +
                this._padzero(d.getUTCDate()) + 'T' + this._padzero(d.getUTCHours()) + ':' +
                this._padzero(d.getUTCMinutes()) + ':' + this._padzero(d.getUTCSeconds()) + '.' + this._pad2zeros(d.getUTCMilliseconds()) + 'Z';
        },

        /**
         * The function Returns current date and time in ISO 8601 format
         *
         * @function
         */
        _currentDateTime : function() {
            var now = new Date();
            return(this._toISOString(now));
        }

    });

    Host.platforms = [["Win","Windows"],["Mac"],["iPhone","iPhone/iPod"],["iPad"],["Linux"],["Unknown"]];

    Host.defineProps({
        "appType" : {
            get : function() {
                return "HTML 5";
            }
        },

        "currentPage" : {
            get : function() {
                if(this.pagingManager)
                    return(this.pagingManager.currentPage());
            },
            set : function(page) {
                var currentPage = 0,
                    lastPage = 0;
                page = parseInt(page);
                if(this.pagingManager) {
                    currentPage = this.pagingManager.currentPage();
                    lastPage = this.pagingManager.pageCount();
                }

                if(page < 0)
                    page = 0;
                else if(page >= lastPage)
                    page =  (lastPage > 0) ? lastPage -1 : 0;

                var $pages = $(".page");

                if( page > $pages.length-1 ) {  // not all pages rendered yet
                    if(this.pagingManager) {
                        while(this.pagingManager.hasMorePages() && currentPage <= page){
                            this.pagingManager.renderNextPage();
                            currentPage++;
                        }
                    }
                    $pages = $(".page");   // select newly rendered pages
                }

                var a = $($pages[page]);
                window.scrollTo(0,a.offset().top) ;
            }
        },

        "name" : {
            get : function() {
                return this._browserDetect();
            }
        },

        "variation" : {
            get : function() {

            }
        },

        "numPages" : {
            get : function() {
                if(this.pagingManager)
                    return(this.pagingManager.pageCount());
            }
        },

        "platform" : {
            get : function() {
                var arr = Host.platforms;
                if (!this.mPlatform) {
                    for(var i = 0;i<arr.length;i++)
                          if(~navigator.platform.indexOf(arr[i][0]))
                                break;
                    i = i == arr.length ? i - 1 :i;
                    this.mPlatform =  arr[i][arr[i].length-1];
                }
                return this.mPlatform
            }
        },

        "title" : {
            get : function() {
                return document.title;
            },
            set : function(title) {
            	title = this.validateInput(title, "string");
                document.title = title;
            },
            enumerable : true
        },

        "version" : {
            get : function() {
                return "1.0";
            }
        },


        "calculationsEnabled" : {
            get : function() {
                return this.mCalculationsEnabled;
            },
            set : function(sCalculationsEnabled) {
            	//sCalculationsEnabled = this.validateInput(sCalculationsEnabled, "string");
                var sOriginalValue = this.mCalculationsEnabled;
                this.mCalculationsEnabled = sCalculationsEnabled;
                if (!sCalculationsEnabled) {
                    //this.xfa._rootSubform._clearMessages(); TODO: Clear Calculation messages
                } else if (sCalculationsEnabled && (sOriginalValue == false)) {
                    this._xfa().form.execCalculate();
                }
            }
        },

        "validationsEnabled" : {
            get : function() {
                return this.mValidataionsEnabled;
            },
            set : function(sValidationsEnabled) {
            	//sValidationsEnabled = this.validateInput(sValidationsEnabled, "string");
                var sOriginalValue = this.mValidataionsEnabled;
                this.mValidataionsEnabled = sValidationsEnabled;
                if (!sValidationsEnabled) {
                    //this.xfa._rootSubform._clearMessages(); TODO: Clear Validation messages
                } else if (sValidationsEnabled && (sOriginalValue == false)) {
                    this._xfa().form._validate();
                }
            }
        }

    });
})(_, xfalib, $);







(function (_, $, xfalib) {
    var XfaTemplateCache = xfalib.script.XfaTemplateCache = xfalib.ut.Class.extend({

        initialize: function () {
            XfaTemplateCache._super.initialize.call(this);
            this._lastID = (new Date()).getTime(); //TODO: Get a better scheme
            this._nodeCache = {};        // live cache
            this._t0JsonNodeCache = {}; // initial cache
            this.idMap = {};           //--map to get the field instance of the corresponding field-id

            var jsonString = JSON.stringify(this.options.initialFormDom), //We create copy of initial form dom via JSON api instead of this.copyObject since that is fast
                initialFormDomCopy = JSON.parse(jsonString),    //Create copy of initial form dom to guard against future modifications
                formDomTemplate = {};   //Copy holding formDomTemplate

            this.copyObject(initialFormDomCopy, formDomTemplate, {"exceptions": ["children"]});
            //Generate template
            this._processTemplate(formDomTemplate, initialFormDomCopy, false);
            var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
            //To maintain backward compatibility
            if (behaviorConfig.isOn('stripInitialFormDom') || behaviorConfig.isOn('mfStripInitialFormDom')) {
                xfalib.ut.XfaUtil.prototype.stripObject(this._t0JsonNodeCache[initialFormDomCopy.extras.htmlId].initialRef,
                                                        ['_class', 'name', 'htmlId', 'presence', 'min', 'max']);
            }
        },

        getTemplateRef: function (htmlId) {
            if (this._nodeCache.hasOwnProperty(htmlId))
                return this._nodeCache[htmlId].templateRef;
            else if (this._t0JsonNodeCache.hasOwnProperty(htmlId))
                return this._t0JsonNodeCache[htmlId].templateRef;
            else
                return null;
        },

        getInitialFormDomRef: function (htmlId) {
            if (this._t0JsonNodeCache.hasOwnProperty(htmlId))
                return this._t0JsonNodeCache[htmlId].initialRef;
            else
                return null;
        },

        getModel: function (htmlId) {
            if (this._nodeCache.hasOwnProperty(htmlId))
                return this._nodeCache[htmlId].model;
            else
                return null;
        },

        putModel: function (model, jsonTemplate) {
            this._processModel(jsonTemplate, model);
        },

        removeModel: function (htmlId) {
            if (this._nodeCache.hasOwnProperty(htmlId))
                delete this._nodeCache[htmlId];
        },

        _processTemplate: function (jsonTemplate, jsonModel, canRepeat) {
            var templateId = null;
            if (this.getOrElse(jsonTemplate, "extras.htmlId", null) == null) {
                jsonTemplate.extras = jsonTemplate.extras || {};
                jsonTemplate.extras.htmlId = "CL_" + (++this._lastID);
                templateId = jsonTemplate.extras.htmlId;
            }
            if (this.getOrElse(jsonModel, "extras.htmlId", null) == null) {
                jsonModel.extras = jsonModel.extras || {};
                if (templateId != null)
                    jsonModel.extras.htmlId = templateId;
                else
                    jsonModel.extras.htmlId = "CL_" + (++this._lastID);
            }
            this._t0JsonNodeCache[jsonModel.extras.htmlId] = {templateRef: jsonTemplate, initialRef: jsonModel};

            if (!canRepeat && !_.contains(["area", "pageSet", "pageArea", "subform", "subformSet", "contentArea", "exclGroup", "form"], jsonModel._class)) {
                //Process it's child only if that can repeat or it can have paintable children. This is badly written check. Need to re-code this.
                return;
            }

            var lastIM = null;
            var lastChildSF = false;
            var childTemplateIndex = -1;
            _.each(jsonModel.children,
                function (childNode, i) {
                    if (this.matchJsonType(childNode, "instanceManager")) {
                        lastIM = childNode;
                    }

                    if (!lastChildSF) {   //If last child was not subform then increase template index
                        childTemplateIndex = childTemplateIndex + 1;
                    } else if (!this.xfaUtil().isRepeatabeEl(childNode._class)) { //Else increase template index only for non-subform
                        childTemplateIndex = childTemplateIndex + 1;
                    }

                    var childRepeat = canRepeat;
                    if (this.xfaUtil().isRepeatabeEl(childNode._class)) {
                        childRepeat = childRepeat || parseInt(this.getOrElse(lastIM, "max", xfalib.script.Occur.prototype._defaults.max)) < 0 ||
                            (parseInt(this.getOrElse(lastIM, "min", xfalib.script.Occur.prototype._defaults.min)) < parseInt(this.getOrElse(lastIM, "max", xfalib.script.Occur.prototype._defaults.max)));
                        lastChildSF = true;
                    }
                    else
                        lastChildSF = false;

                    jsonTemplate.children = jsonTemplate.children || [];
                    var childTemplate = jsonTemplate.children[childTemplateIndex];
                    if (!childTemplate) {
                        childTemplate = {
                            _class: childNode._class,
                            name: childNode.name,
                            extras: childNode.extras || {}
                        };
                        if (childRepeat) { //For repeatable child copy all properties
                            this.copyObject(childNode, childTemplate, {exceptions: ["children"], keepReference: false});
                        }
                        jsonTemplate.children.push(childTemplate);
                    }
                    this._processTemplate(childTemplate, childNode, childRepeat);
                }, this);
        },

        _processModel: function (jsonTemplate, model) {
            if (model.htmlId == null) {
                model.htmlId = "CL_" + (++this._lastID);
            }
            this._nodeCache[model.htmlId] = {templateRef: jsonTemplate, model: model};
            var childTemplateIndex = -1;
            var lastChildSF = false;
            _.each(model.children,
                function (childNode, i) {
                    if (!lastChildSF) {   //If last child was not subform then increase template index
                        childTemplateIndex = childTemplateIndex + 1;
                    } else if (!(childNode instanceof xfalib.script.Subform)) { //Else increase template index only for non-subform
                        childTemplateIndex = childTemplateIndex + 1;
                    }

                    lastChildSF = childNode instanceof xfalib.script.Subform;

                    var childTemplate = jsonTemplate.children ? jsonTemplate.children[childTemplateIndex] : undefined
                    if (childTemplate)
                        this._processModel(childTemplate, childNode);
                }, this);
        },

        matchJsonType: xfalib.ut.XfaUtil.prototype.matchJsonType

    });

})(_, $, xfalib);
/**
 * @package xfalib.script.Xfa
 * @import xfalib.script.Model
 * @import xfalib.ut.Logger
 * @import xfalib.script.Host
 * @import xfalib.script.XfaModelEvent
 * @fileOverview The file creates the XFA Class required for XFA library
 * @version 0.0.1
 */

(function (_, xfalib) {
    /**
     * @class The class represents the XFA Object
     * @extends com.adobe.xfa.scripting.Model
     * @property {com.adobe.xfa.scripting.Host} host Object of the host class
     */
    var Xfa = xfalib.script.Xfa = xfalib.script.Model.extend({
        msClassName: "xfa",
        initialize: function () {
            xfalib.runtime.xfa = this;                           //TODO: Handle anithing being used before super
            xfalib.runtime["$xfa"] = this;
            this.$layout = this.layout = new xfalib.script.Layout({"jsonModel": {}});
            var logConf = window.formBridge.registerConfig("LoggerConfig").data || {};
            var renderContextCopy = {};
            this.copyObject(xfalib.runtime.renderContext, renderContextCopy, {"exceptions": ["data"]})
            xfalib.runtime.xfa.Logger = new xfalib.ut.Logger({
                "jsonModel": logConf,
                logServiceProxy: this.getOrElse(window.formBridge.userConfig["submitServiceProxyConfig"], "logServiceProxy", ""),
                renderContext: renderContextCopy,
                contextPath: window.formBridge.userConfig["contextPath"]
            });
            xfalib.runtime.xfa.ErrorManager = this.getOrElse(window.formBridge.userConfig["errorConfig"],new xfalib.view.util.ErrorManager)
            xfalib.script.Xfa.Instance = this;          //TODO: Singleton reqd?
            this._submitButtons = [];
            this._modelInitialize = 'UNINITIALIZED'; // can be set to 'INITIALIZED' or ''INITIALIZING'
            this.moContextNodes = [];
            this.moCalculateEventStack = [];
            this.moCalculateEventNode = null;
            this.host = new xfalib.script.Host();
            xfalib.runtime["$host"] = this.host;
            this.countError = 0;
            this.dataNodes = {};
            this._templateSchema = new xfalib.template.TemplateSchema();
            this.moContextScriptEvent = null; // will hold current event for which script is executing
            this.Queue = {"calc": [], "calcindex": 0, "validate": [], "validateindex": 0, calcCount: {},
                "setfocus": [], "setfocusindex": 0};

            // to clear all _moContext-s cached in eventContainerNode-s, after subform.addInstance or subform.removeInstance
            xfalib.runtime.xfa._clearAllMoContexts = function () {
                function clearMoContextVisitor(target) {
                    if (target instanceof xfalib.script.EventContainerNode) {
                        target._moContext = null;
                    }
                }
                xfalib.runtime.xfa.form._getRootSubform()._visitAllmoChildren(clearMoContextVisitor);
            };

            //Create Form Child
            var formJson = _.find(this.jsonModel.children, function (child) {
                return child._class == "form";
            });
            this._xfaTemplateCache = new xfalib.script.XfaTemplateCache({initialFormDom: formJson});

            //We call Super later at this stage since we need to initialize few variables which are required while initializing children
            Xfa._super.initialize.call(this);

            //get the child from children models that are already created.
            this.form = _.find(this.children, function (child) {
                return child._isForm();
            });
            this._xfaTemplateCache.putModel(this.form,
                this._xfaTemplateCache.getTemplateRef(this.getOrElse(formJson, "extras.htmlId", {}))
            );

            //Note: since we do not support template currently, we workarond by pointing template node to form node which would have similar structure in most cases.
            xfalib.runtime['$template'] = this.template = xfalib.runtime['$form'] = this.form;
            xfalib.runtime['template'] = xfalib.runtime['form'] = this.form;

            //Create Config Child. Notice that it is not XFA Node model, just a json child for now.
            this.config = _.find(this.jsonModel.children, function (child) {
                return child._class == "config";
            });
            xfalib.runtime['$config'] = this.config;

            //Create localeSet Child. Notice that it is not XFA Node model, just a json child for now.
            this.localeSet = this.jsonModel.localeSet;
            this.defaultLocale = "en_US"; //TODO: read from jsp

            //Once everything is set up, now is the time to set parent access
            this.form._calculateEffectiveAccess();
            this.form._calculateEffectivePresence();
            this.calculateRunning = false;
            this.validateRunning = false;
            this.versionConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
        },

        /**
         * Evaluates the specified SOM expression, beginning with the current XML form
         * object model object, and returns the value of the object specified in the SOM
         * expression
         * @Overrides
         * @function
         */
        resolveNode: function () {
            if (arguments.length == 1)
                return Xfa._super.resolveNode.call(this, this._contextNode() || this, arguments[0]);
            else
                return Xfa._super.resolveNode.call(this, arguments[0], arguments[1]);
        },

        /**
         * Evaluates the specified SOM expression, beginning with the current XML form
         * object model object, and returns the value of the object specified in the SOM
         * expression
         * @Overrides
         * @function
         */
        resolveNodes: function () {
            if (arguments.length == 1)
                return Xfa._super.resolveNodes.call(this, this._contextNode(), arguments[0]);
            else
                return Xfa._super.resolveNodes.call(this, arguments[0], arguments[1]);
        },

        _newSubmitButton: function (elem) {
            if (!~this._submitButtons.indexOf(elem))     //TODO: What is this. Add a comment
                this._submitButtons.push(elem);
        },

        _hideSubmitButtons: function (elem) {
            for (var i = 0; i < this._submitButtons.length; i++) {
                this._submitButtons[i].presence = "hidden";
            }
        },

        /**
         * The function pushes a new Calculate Event Node into the Calculate Stack
         * @function
         * @param {com.adobe.xfa.scripting.Node} node current context node
         * @private
         */
        _pushCalculateEventNode: function (node) {
            this.moCalculateEventStack.push(node);
            this.moCalculateEventNode = node;
        },

        /**
         * The function pushes a new XFA Node in the current context
         * @function
         * @param {com.adobe.xfa.scripting.Node} node current context node
         * @private
         */
        _pushContextNode: function (node) {
            this.moContextNodes.push(node);
        },

        /**
         * The function pops Calculate Event Node from the stack of context nodes
         * @function
         * @private
         */
        _popCalculateEventNode: function () {
            this.moCalculateEventStack.pop();
            this.moCalculateEventNode = null;
        },

        /**
         * The function pops a XFA Node from the stack of context nodes
         * @function
         * @private
         */
        _popContextNode: function () {
            this.moContextNodes.pop();
        },

        _contextNode: function () {
            var len = this.moContextNodes.length;
            if (len > 0)
                return this.moContextNodes[len - 1]
            return null;
        },

        _isXFAContainerNode: function () {
            return true;
        },

        _getSomExpression: function () {
            return this.getAttribute("name") + "[" + this.index + "]";
        },

        _getLocaleSymbols: function (locale, symbol) {
            var ret = null;
            var newSymbol = "locales." + locale + "." + symbol;
            ret = this.getOrElse(this.localeSet, newSymbol, xfalib.ut.XfaUtil.prototype.getDefaultLocaleProperty(symbol));
            if (!ret) {
                xfalib.runtime.xfa.Logger.error("xfa", "unable to find " + symbol + " for locale " + locale + "in localeSet");
            }
            return ret;
        },

        setSubformFocus: function (subform) {
            var oldSubform = this.currentSubform;
            this.currentSubform = subform;
            var views = [];
            if (oldSubform) {
                var pSubform = subform;
                while (pSubform) {
                    views.push(pSubform);
                    pSubform = pSubform.parent;
                }
                while (oldSubform && views.indexOf(oldSubform) == -1) {
                    oldSubform.execEvent("exit");
                    oldSubform = oldSubform.parent;
                }
            }
        },

        createDataNode: function (id, model) {
            if (id) {
                var dn = this.dataNodes[id] || xfalib.script.XfaModelRegistry.prototype.createDataNode(id);
                dn.addField(model);
                this.dataNodes[id] = dn;
            }
        },

        queueCalcEvent: function (oListener) {
            if (!this.host.calculationsEnabled)
                return;
            var q = this.Queue["calc"];
            var som = oListener.somExpression;
            for (var i = 0; i < q.length; i++) {
                var item = q[i];
                if (oListener == item) {
                    if (i < this.Queue.calcindex) {
                        if (this.Queue.calcCount[som] === 10)
                            return;
                    }
                    else
                        return;
                }
            }
            this.Queue.calcCount[som] = this.Queue.calcCount[som] || 0;
            this.Queue.calcCount[som]++;
            q.push(oListener);
        },

        queueValidateEvent: function (oNode) {
            if (!this.host.validationsEnabled)
                return;
            if (!~this.Queue["validate"].indexOf(oNode))
                this.Queue["validate"].push(oNode);
        },

        queueFocusEvent: function (context, som) {
            this.Queue["setfocus"].push({'context': context, 'som': som});
        },

        runQueue: function (queue, evnt) {
            if (queue !== "calc" && queue !== "validate")
                return;
            if (queue == "calc" && !this.host.calculationsEnabled)
                return;
            if (queue == "validate" && !this.host.validationsEnabled)
                return;
            var Q = this.Queue[queue];
            var ind = this.Queue[queue + "index"];
            for (var i = ind; i < Q.length; i++) {
                this.Queue[queue + "index"]++;
                if (evnt === "validate") {
                    Q[i]._validate([]);
                }
                else {
                    Q[i].execEvent(evnt);
                }
            }
        },

        runCalcAndValidate: function () {
            this._pushContextNode(this.form);
            this.runCalcs();
            this.runValidates();
            this.runSetFocuses();
            this.Queue["calc"] = [];
            this.Queue.calcindex = 0;
            this.Queue.calcCount = {};
            this.Queue["validate"] = [];
            this.Queue.validateindex = 0;
            this.Queue["setfocus"] = [];
            this.Queue.setfocusindex = 0;
            this._popContextNode();
        },

        runCalcs: function (start) {
            if (typeof start != "undefined" && start === "true")
                this.Queue.calcindex = 0;
            this.calculateRunning = true;
            this.runQueue("calc", "calculate");
            this.calculateRunning = false;
        },

        runValidates: function () {
            this.validateRunning = true;
            this.runQueue("validate", "validate")
            this.validateRunning = false;
        },

        runSetFocuses: function () {
            var Q = this.Queue["setfocus"],
                index = this.Queue["setfocusindex"];
            for (var i = index; i < Q.length; i++) {
                this.Queue["setfocusindex"]++;
                var som = Q[i]['som'],
                    node = som,
                    context = Q[i]['context'];
                if (typeof som == "string")
                    node = context._xfa().resolveNode(som);
                if (node != null) {
                    if (context.pagingManager) {
                        if (navigator.userAgent.match(/iPad/i) == null) {
                            xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(
                                setTimeout(function () {
                                    context.pagingManager._makePageForHtmlId(node.htmlId, node._setFocus, node);
                                })
                            );  // just give browser enough time to register the keypress
                        } else {
                            context.pagingManager._makePageForHtmlId(node.htmlId, node._setFocus, node); // $.focus() doesn't work inside setTimeout in iPad
                        }
                    }
                }
            }
        },

        _computeJsonDiff: function (diff_level) {
            var formDiff = this.form._computeJsonDiff(diff_level);
            var dest = {
                _class: this.className,
                name: "xfa",
                versionNS: this.jsonModel.versionNS,
                children: [formDiff.jsonDifference]
            };

            return { "changed": true,
                "jsonDifference": dest
            };
        }
    });

    Xfa._defaultLocale = {
        "calendarSymbols": {
            "monthNames": ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
            "abbrmonthNames": ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
            "dayNames": ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
            "abbrdayNames": ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
            "meridiemNames": ["AM", "PM"],
            "eraNames": ["BC", "AD"]
        },
        "datePatterns": {
            "full": "EEEE D MMMM YYYY",
            "long": "D MMMM YYYY",
            "med": "DD-MMM-YY",
            "short": "DD/MM/YY"
        },
        "timePatterns": {
            "full": "h:MM:SS A Z",
            "long": "h:MM:SS A Z",
            "med": "h:MM:SS A",
            "short": "h:MM A"
        },
        "dateTimeSymbols": "GyMdkHmsSEDFwWahKzZ",
        "numberPatterns": {
            "numeric": "z,zz,zz9.zzz",
            "currency": "$ z,zz,zz9.99",
            "percent": "z,zz,zz9%"
        },
        "numberSymbols": {
            "decimal": ".",
            "grouping": ",",
            "percent": "%",
            "minus": "-",
            "zero": "0"
        },
        "currencySymbols": {
            "symbol": "$",
            "isoname": "USD",
            "decimal": "."
        },
        "typefaces": {}
    }
})(_, xfalib);
/**
 * @package xfalib.script.XfaModelRegistry
 * @import xfalib.ut.Class
 */
(function(_, xfalib){
    var XfaModelRegistry = xfalib.script.XfaModelRegistry = xfalib.ut.Class.extend({

        _classToFactoryMap : {
            "script" : "createScript",
            "exclGroup" : "createExclusionGroup",

            "arc" : "createNodeValue",
            "boolean": "createNodeValue",
            "date": "createNodeValue",
            "dateTime": "createNodeValue",
            "decimal": "createNodeValue",
            "exData": "createNodeValue",
            "float": "createNodeValue",
            "image": "createNodeValue",
            "integer": "createNodeValue",
            "line": "createNodeValue",
            "rectangle": "createNodeValue",
            "text": "createNodeValue",
            "time": "createNodeValue"

        },

        createModel : function(jsonModel){
            var model = null;
            var elClass = jsonModel._class.charAt(0).toUpperCase() + jsonModel._class.substr(1);
            var factoryFnName = "create" + elClass ;
            if(this._classToFactoryMap[jsonModel._class]){
                factoryFnName = this._classToFactoryMap[jsonModel._class];
            }
            if(this[factoryFnName])
                model = this[factoryFnName].call(this, jsonModel);


            if(!model && xfalib.script.dom[elClass]){
                model = new xfalib.script.dom[elClass]({"jsonModel" : jsonModel});
            }

            if(!model) {
                model = new xfalib.script.Node({"jsonModel" : jsonModel});
            }
            return model;
        },

        createXfa : function(json){
            return new xfalib.script.Xfa({"jsonModel" : json});
        },

        createForm : function(json){
            return new xfalib.script.Form({"jsonModel" : json});
        },

        createConfig : function(json){
            return json;      //No seperate model API for config for now
        },

        createTextField : function(field) {
            return new xfalib.script.Field({"jsonModel" : field});
        },

        createImageField : function(field) {
            return new xfalib.script.Field({"jsonModel" : field});
        },

        createDateTimeField : function(field) {
            return new xfalib.script.DateTimeField({"jsonModel" : field});
        },

        createNumericField : function(field) {
            return new xfalib.script.NumericField({"jsonModel" : field});
        },

        createChoiceListField : function(field) {
            return new xfalib.script.ChoiceListField({"jsonModel" : field});
        },

        createButtonField : function(field) {
            return new xfalib.script.ButtonField({"jsonModel" : field});
        },

        createCheckButtonField : function(field) {
            return new xfalib.script.CheckButtonField({"jsonModel" : field});
        },

        createTextDraw : function(draw) {
            return new xfalib.script.Draw({"jsonModel" : draw});
        },

        createInstanceManager : function(oInstanceManager) {
            return new xfalib.script.InstanceManager({"jsonModel" : oInstanceManager});
        },

        createPageSet: function(vPageSet) {
            return new xfalib.script.PageSet({"jsonModel" : vPageSet});
        },

        createPageArea: function(vPageArea) {
            return new xfalib.script.PageArea({"jsonModel" : vPageArea});
        },

        createContentArea: function(vContentArea) {
            return new xfalib.script.ContentArea({"jsonModel" : vContentArea});
        },

        createExclusionGroup : function(exclGroup) {
            return new xfalib.script.ExclusionGroup({"jsonModel" : exclGroup});
        },

        createSubform: function(vSubform) {
            return new xfalib.script.Subform({"jsonModel" : vSubform});
        },

        createArea: function(vArea) {
            return new xfalib.script.Area({"jsonModel" : vArea});
        },

        createSubformSet: function(vSubformSet) {
            return new xfalib.script.SubformSet({"jsonModel" : vSubformSet});
        },

        createVariables: function(vVariables) {
            return new xfalib.script.Variables({"jsonModel" : vVariables});
        },

        createScript: function(vScript) {
            if(vScript._parentClass && vScript._parentClass == "variables"){
                return new xfalib.script.dom.ScriptObject({"jsonModel" : vScript});
            }
            else {
                return new xfalib.script.dom.Script({"jsonModel" : vScript});
            }
        },

        createField : function(field) {
            var t = null;
            var childType = this.getOrElse(this.xfaUtil().getUiOneOfChildTag(field), "").toLowerCase();
            switch (childType) {
                case "datetimeedit":
                    t =this.createDateTimeField(field)
                    break;
                case "textedit":
                    t = this.createTextField(field);
                    break;
                case "imageedit":
                    t = this.createImageField(field);
                    break;
                case "numericedit":
                    t = this.createNumericField(field);
                    break;
                case "choicelist":
                    t = this.createChoiceListField(field);
                    break;
                case "button":
                    t = this.createButtonField(field);
                    break;
                case "checkbutton":
                    t = this.createCheckButtonField(field);
                    break;
                default:
                    //xfa.Logger.warn("unknown uiType for the field " + field.ui.type + " <"
                    //    + field.name + "> Creating a TextField instead");
                    t = this.createTextField(field);
                    break;
            }
            return t;
        },

        createDraw : function(draw) {
            var t = null;
            var childType = this.getOrElse(this.xfaUtil().getUiOneOfChildTag(draw), "").toLowerCase();
            switch (childType) {
                case "textedit":
                    t = this.createTextDraw(draw);
                    break;
                default:
                    //xfa.Logger.warn("unknown uiType for the draw " + draw.ui.type + " <"
                    //    + draw.name + "> Creating a Static Text instead");
                    t = this.createTextDraw(draw);
                    break;
            }
            return t;
        },

        createSomExpression : function(sExpression, nDefaultOccurrence, bIgnorePredicate) {
            var options = {
                expression : sExpression,
                defaultOccurrence : nDefaultOccurrence,
                ignorePredicate : bIgnorePredicate
            }
            return new xfalib.script.SOMExpression(options);
        },

        createValue: function(valueJson) {
            return new xfalib.script.dom.Value({"jsonModel" : valueJson});
        },

        createNodeValue : function(valueJson) {
            //ToDo : this is a stop grap measure till we find a way to handle default valueJson
            valueJson = valueJson || {_class: "", rawValue: ""};
            var valType = valueJson._class.toLowerCase();
            switch (valType) {
                case "text":
                    return new xfalib.script.TextValue({"jsonModel" : valueJson});
                case "integer":
                    return new xfalib.script.IntegerValue({"jsonModel" : valueJson});
                case "decimal":
                	return new xfalib.script.DecimalValue({"jsonModel" : valueJson});
                case "float":
                    return new xfalib.script.FloatValue({"jsonModel" : valueJson}); 
                case "exdata":
                    return new xfalib.script.ExDataValue({"jsonModel" : valueJson});
                case "date":
                    return new xfalib.script.DateValue({"jsonModel" : valueJson});
                case "image":
                    return new xfalib.script.ImageValue({"jsonModel" : valueJson});
                case "script":
                    return this.createScript(valueJson);
                default:
                    //xfa.Logger.warn("unknown value type " + valueJson.type + " for element <"
                    //    + this.name + ">");
                    return new xfalib.script.NodeValue({"jsonModel" : valueJson});
            }
        },

        createDataNode: function(id) {
            return new xfalib.script.DataNode({"jsonModel" : {"id":id}});
        }

    });

})(_, xfalib);
(function(_, xfalib){
    var App = xfalib.acrobat.App =  xfalib.ut.Class.extend({
        initialize : function() {
            App._super.initialize.call(this);
            xfalib.runtime.app = this;
            this._version = window.formBridge.getBridgeVersion();

        },

        alert: function(cMsg) {
            return window.alert(cMsg);
        },

        beep: function(nType) {

        },


        execDialog: function(dialog) {

        },

        launchURL: function(url, bNewFrame) {
            if(url.search("http") == -1)
                url = "http://" + url ;
            if(bNewFrame != true) {
                window.open(url) ;
            }
            else
                window.location = url;
        },

        setTimeOut: function(cExpr, nMilliseconds) {
            try {
                var fn = new Function(this._within(cExpr));
                return window.setTimeout(function() {
                     fn.call(xfalib.runtime.Document);
                }, nMilliseconds);
            } catch(ex) {
                console.log(ex);
            }
        },

        setInterval: function(cExpr, nMilliseconds) {
            try {
                var fn = new Function(this._within(cExpr));
                return window.setInterval(function() {
                    fn.call(xfalib.runtime.Document);
                }, nMilliseconds);
            } catch(ex) {
                console.log(ex);
            }
        },

        clearTimeOut: function(oTime) {
            window.clearTimeout(oTime);
        },

        clearInterval: function(oInterval) {
            window.clearInterval(oInterval);
        },

        eval: function(script) {
            window.eval(this._within(script));
        },

        _within: function(script){
            var string  =   "try {\n" +
                                "with(xfalib.runtime.Document) {\n" +
                                    "with(xfalib.runtime) {\n" +
                                        script +"\n" +
                                    "}\n" +
                                "}\n" +
                            "} catch(ex) {\n" +
                                "console.log(ex)\n" +
                            "}";
            return string;
        }

    });

    App.defineProps({
        "activeDocs" : {
            get : function() {
                return ([]);
            }
        },

        "calculate" : {
            get : function() {
                return (true);
            }
        },

        "constants" : {
            get : function() {
                return ({align:{}});
            }
        },

        "focusRect" : {
            get : function() {
                return (true);
            }
        },

        "formsVersion" : {
            get : function() {
                return (this._version);
            }
        },

        "fromPDFConverters" : {
            get : function() {
                return ([]);
            }
        },

        "fs" : {
            get : function() {
                return ({isFullScreen: false});
            }
        },

        "fullscreen" : {
            get : function() {
                return (false);
            }
        },

        "language" : {
            get : function() {
                if(navigator.language.substr(0,2) === "en")
                    return ("ENU");
                return ("ENU");
            }
        },

        "platform" : {
            get : function() {
                if(navigator.appVersion.indexOf("Win") != -1)
                    return ("WIN");
                if(navigator.appVersion.indexOf("Mac") != -1)
                    return ("MAC");
                return ("UNIX");
            }
        },

        "viewerType" : {
            get : function() {
                return ("Exchange-Pro");
            }
        },

        "viewerVariation" : {
            get : function() {
                return ("Full");
            }
        },

        "viewerVersion" : {
            get : function() {
                return (this._version);
            }
        }
    })

})(_, xfalib);

(function(_, xfalib){
    var Console = xfalib.acrobat.Console =  xfalib.ut.Class.extend({
        initialize : function(bRegister) {
            Console._super.initialize.call(this);
            if(bRegister)
                xfalib.runtime.console = this;
        },

        println: function() {
            //add this method to insert console where 'console' is not supported
        }
    });

})(_, xfalib);

(function(_, xfalib){
    var Acrobat = xfalib.acrobat.Acrobat =  xfalib.ut.Class.extend({
        initialize : function() {
            Acrobat._super.initialize.call(this);
            //initialize App object
            new xfalib.acrobat.App();
            //insert println inside console object
            if(typeof(console) != "undefined") {
                if(console.log)
                    console.println = console.log;
                else {
                    //register empty method
                    var con = new xfalib.acrobat.Console();
                    console.println = con.println;
                }
            }
            else {
                new xfalib.acrobat.Console(true);
            }
        }
    });

})(_, xfalib);

/**
 * Created with IntelliJ IDEA.
 * User: vdua
 * Date: 21/5/13
 * Time: 5:56 PM
 * To change this template use File | Settings | File Templates.

 /**
 * @package xfalib.script.XfaModelEvent
 * @import xfalib.script.Object
 * @fileOverview The file creates the XfaModelEvent Class required for XFA library
 * @version 0.0.1
 */
(function(_,xfalib) {

    var Field = xfalib.acrobat.Field = xfalib.ut.Class.extend({
        initialize : function() {
            Field._super.initialize.call(this);
            this._xfaField = xfalib.script.Xfa.Instance.resolveNode("xfa.form."+this.jsonModel.somExpression);
        },

        signatureInfo : function() {
            throw {message:"signatureInfo is not supported"}
        },

        setFocus: function() {
            xfalib.script.Xfa.Instance.host.setFocus(this.jsonModel.somExpression);
        }
    });

    Field.defineProps({

    })
})(_,xfalib);
/**
 * @package xfalib.script.XfaModelEvent
 * @import xfalib.script.Object
 * @fileOverview The file creates the XfaModelEvent Class required for XFA library
 * @version 0.0.1
 */
(function(_,xfalib) {

    var Doc = xfalib.acrobat.Doc = xfalib.ut.Class.extend({

        getURL: function() {
            return window.location.href;
        },

        resetForm: function(fieldArray) {
            if(!(fieldArray instanceof Array)) {
                fieldArray = [fieldArray];
            }
            this.xfa.host.resetData.apply(this.xfa.host,fieldArray);
        },

        submitForm: function() {
            this.xfa.Logger.error("xfa",xfalib.locale.LogMessages["ALC-FRM-901-006"],["submitForm"]);
        },

        getField: function(som) {
            return new xfalib.acrobat.Field({"jsonModel" : {"somExpression": som}});
        },

        importDataObject: function() {
            throw {message:"importDataObject is not supported"}
        }

    });

    Doc.defineProps({
        "xfa" : {
            get: function() {
                return xfalib.script.Xfa.Instance;
            }
        }

    })

    xfalib.runtime.Document = new xfalib.acrobat.Doc({jsonModel:{}});

})(_,xfalib);
/**
 * @package xfalib.script.XfaModelEvent
 * @import xfalib.script.Object
 * @fileOverview The file creates the XfaModelEvent Class required for XFA library
 * @version 0.0.1
 */
(function(_,xfalib) {

    var AcroEvent = xfalib.acrobat.AcroEvent = xfalib.script.XfaModelEvent.extend({
        msClassName: "acroEvent",
        initialize : function() {
            xfalib.script.XfaModelEvent._super.initialize.call(this);
            this.jsonModel.target = xfalib.runtime.Document;
        }
    });

    AcroEvent.cloneEvent = function(xfaModelEvent) {
        var copy = xfaModelEvent.copyObject(xfaModelEvent.jsonModel, {},{"exceptions":["target"]});
        return new AcroEvent({"jsonModel" : copy});
    };

})(_,xfalib);
(function (_, xfalib) {
    var AppearanceFilter = xfalib.script.dom.AppearanceFilter = xfalib.script.GenericText.extend({
        msClassName:"appearanceFilter"
    });

    AppearanceFilter.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Assist = xfalib.script.dom.Assist = xfalib.script.DOMElement.extend({
        msClassName:"assist"
    });

    Assist.defineProps({
        role:{
            get:function () {
                return this.getAttribute("role");
            },
            set:function (value) {
                this.setAttribute(value, "role");
            }
        },
        speak:{
            get:function () {
                return this.getElement("speak", 0);
            },
            set:function (value) {
                this.setElement(value, "speak");
            }
        },
        toolTip:{
            get:function () {
                return this.getElement("toolTip", 0);
            },
            set:function (value) {
                this.setElement(value, "toolTip");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Barcode = xfalib.script.dom.Barcode = xfalib.script.DOMElement.extend({
        msClassName:"barcode"
    });

    Barcode.defineProps({
        charEncoding:{
            get:function () {
                return this.getAttribute("charEncoding");
            },
            set:function (value) {
                this.setAttribute(value, "charEncoding");
            }
        },
        checksum:{
            get:function () {
                return this.getAttribute("checksum");
            },
            set:function (value) {
                this.setAttribute(value, "checksum");
            }
        },
        dataColumnCount:{
            get:function () {
                return this.getAttribute("dataColumnCount");
            },
            set:function (value) {
                this.setAttribute(value, "dataColumnCount");
            }
        },
        dataLength:{
            get:function () {
                return this.getAttribute("dataLength");
            },
            set:function (value) {
                this.setAttribute(value, "dataLength");
            }
        },
        dataPrep:{
            get:function () {
                return this.getAttribute("dataPrep");
            },
            set:function (value) {
                this.setAttribute(value, "dataPrep");
            }
        },
        dataRowCount:{
            get:function () {
                return this.getAttribute("dataRowCount");
            },
            set:function (value) {
                this.setAttribute(value, "dataRowCount");
            }
        },
        endChar:{
            get:function () {
                return this.getAttribute("endChar");
            },
            set:function (value) {
                this.setAttribute(value, "endChar");
            }
        },
        errorCorrectionLevel:{
            get:function () {
                return this.getAttribute("errorCorrectionLevel");
            },
            set:function (value) {
                this.setAttribute(value, "errorCorrectionLevel");
            }
        },
        moduleHeight:{
            get:function () {
                return this.getAttribute("moduleHeight");
            },
            set:function (value) {
                this.setAttribute(value, "moduleHeight");
            }
        },
        moduleWidth:{
            get:function () {
                return this.getAttribute("moduleWidth");
            },
            set:function (value) {
                this.setAttribute(value, "moduleWidth");
            }
        },
        printCheckDigit:{
            get:function () {
                return this.getAttribute("printCheckDigit");
            },
            set:function (value) {
                this.setAttribute(value, "printCheckDigit");
            }
        },
        rowColumnRatio:{
            get:function () {
                return this.getAttribute("rowColumnRatio");
            },
            set:function (value) {
                this.setAttribute(value, "rowColumnRatio");
            }
        },
        startChar:{
            get:function () {
                return this.getAttribute("startChar");
            },
            set:function (value) {
                this.setAttribute(value, "startChar");
            }
        },
        textLocation:{
            get:function () {
                return this.getAttribute("textLocation");
            },
            set:function (value) {
                this.setAttribute(value, "textLocation");
            }
        },
        truncate:{
            get:function () {
                return this.getAttribute("truncate");
            },
            set:function (value) {
                this.setAttribute(value, "truncate");
            }
        },
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        upsMode:{
            get:function () {
                return this.getAttribute("upsMode");
            },
            set:function (value) {
                this.setAttribute(value, "upsMode");
            }
        },
        wideNarrowRatio:{
            get:function () {
                return this.getAttribute("wideNarrowRatio");
            },
            set:function (value) {
                this.setAttribute(value, "wideNarrowRatio");
            }
        },
        encrypt:{
            get:function () {
                return this.getElement("encrypt", 0);
            },
            set:function (value) {
                this.setElement(value, "encrypt");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Bind = xfalib.script.dom.Bind = xfalib.script.DOMElement.extend({
        msClassName:"bind"
    });

    Bind.defineProps({
        match:{
            get:function () {
                return this.getAttribute("match");
            },
            set:function (value) {
                this.setAttribute(value, "match");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var BindItems = xfalib.script.dom.BindItems = xfalib.script.GenericText.extend({
        msClassName:"bindItems"
    });

    BindItems.defineProps({
        connection:{
            get:function () {
                return this.getAttribute("connection");
            },
            set:function (value) {
                this.setAttribute(value, "connection");
            }
        },
        labelRef:{
            get:function () {
                return this.getAttribute("labelRef");
            },
            set:function (value) {
                this.setAttribute(value, "labelRef");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        valueRef:{
            get:function () {
                return this.getAttribute("valueRef");
            },
            set:function (value) {
                this.setAttribute(value, "valueRef");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Bookend = xfalib.script.dom.Bookend = xfalib.script.GenericText.extend({
        msClassName:"bookend"
    });

    Bookend.defineProps({
        leader:{
            get:function () {
                return this.getAttribute("leader");
            },
            set:function (value) {
                this.setAttribute(value, "leader");
            }
        },
        trailer:{
            get:function () {
                return this.getAttribute("trailer");
            },
            set:function (value) {
                this.setAttribute(value, "trailer");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Border = xfalib.script.dom.Border = xfalib.script.DOMElement.extend({
        msClassName:"border",

        handleEvent: function (evnt) {
            if(evnt._property == 'edge.color.value') {
                //If the color is being set for first border edge, and the corner are rounded - set for all the edges
                //reason: In case of rounded corner, we divide the single edge into 4 edges, and thus when trying to set
                //the color for all of them together, only first is set - NPR-15444
                var isFirstIndex = evnt.target.parent.mnClassIndex == 0,
                    isRoundedBorder = !!(parseInt(this.corner.radius));
                if(isFirstIndex && isRoundedBorder) {
                    var index = 1,
                        edge;
                    while (edge = this.getElement('edge', index, true)) {
                        //set the value in case a different color has not been set for a different edge explicitly
                        edge.color.setAttribute(evnt.target.value,'value');
                        index++;
                    }
                }
            }
            Border._super.handleEvent.call(this, evnt);
        }
    });

    Border.defineProps({
        "break":{
            get:function () {
                return this.getAttribute("break");
            },
            set:function (value) {
                this.setAttribute(value, "break");
            }
        },
        hand:{
            get:function () {
                return this.getAttribute("hand");
            },
            set:function (value) {
                this.setAttribute(value, "hand");
            }
        },
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
            }
        },
        relevant:{
            get:function () {
                return this.getAttribute("relevant");
            },
            set:function (value) {
                this.setAttribute(value, "relevant");
            }
        },
        corner:{
            get:function () {
                return this.getElement("corner", 0);
            },
            set:function (value) {
                this.setElement(value, "corner");
            }
        },
        edge:{
            get:function () {
                return this.getElement("edge", 0);
            },
            set:function (value) {
                this.setElement(value, "edge");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        fill:{
            get:function () {
                return this.getElement("fill", 0);
            },
            set:function (value) {
                this.setElement(value, "fill");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Break = xfalib.script.dom.Break = xfalib.script.DOMElement.extend({
        msClassName:"break"
    });

    Break.defineProps({
        after:{
            get:function () {
                return this.getAttribute("after");
            },
            set:function (value) {
                this.setAttribute(value, "after");
            }
        },
        afterTarget:{
            get:function () {
                return this.getAttribute("afterTarget");
            },
            set:function (value) {
                this.setAttribute(value, "afterTarget");
            }
        },
        before:{
            get:function () {
                return this.getAttribute("before");
            },
            set:function (value) {
                this.setAttribute(value, "before");
            }
        },
        beforeTarget:{
            get:function () {
                return this.getAttribute("beforeTarget");
            },
            set:function (value) {
                this.setAttribute(value, "beforeTarget");
            }
        },
        bookendLeader:{
            get:function () {
                return this.getAttribute("bookendLeader");
            },
            set:function (value) {
                this.setAttribute(value, "bookendLeader");
            }
        },
        bookendTrailer:{
            get:function () {
                return this.getAttribute("bookendTrailer");
            },
            set:function (value) {
                this.setAttribute(value, "bookendTrailer");
            }
        },
        overflowLeader:{
            get:function () {
                return this.getAttribute("overflowLeader");
            },
            set:function (value) {
                this.setAttribute(value, "overflowLeader");
            }
        },
        overflowTarget:{
            get:function () {
                return this.getAttribute("overflowTarget");
            },
            set:function (value) {
                this.setAttribute(value, "overflowTarget");
            }
        },
        overflowTrailer:{
            get:function () {
                return this.getAttribute("overflowTrailer");
            },
            set:function (value) {
                this.setAttribute(value, "overflowTrailer");
            }
        },
        startNew:{
            get:function () {
                return this.getAttribute("startNew");
            },
            set:function (value) {
                this.setAttribute(value, "startNew");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var BreakAfter = xfalib.script.dom.BreakAfter = xfalib.script.DOMElement.extend({
        msClassName:"breakAfter"
    });

    BreakAfter.defineProps({
        leader:{
            get:function () {
                return this.getAttribute("leader");
            },
            set:function (value) {
                this.setAttribute(value, "leader");
            }
        },
        startNew:{
            get:function () {
                return this.getAttribute("startNew");
            },
            set:function (value) {
                this.setAttribute(value, "startNew");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        targetType:{
            get:function () {
                return this.getAttribute("targetType");
            },
            set:function (value) {
                this.setAttribute(value, "targetType");
            }
        },
        trailer:{
            get:function () {
                return this.getAttribute("trailer");
            },
            set:function (value) {
                this.setAttribute(value, "trailer");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var BreakBefore = xfalib.script.dom.BreakBefore = xfalib.script.DOMElement.extend({
        msClassName:"breakBefore"
    });

    BreakBefore.defineProps({
        leader:{
            get:function () {
                return this.getAttribute("leader");
            },
            set:function (value) {
                this.setAttribute(value, "leader");
            }
        },
        startNew:{
            get:function () {
                return this.getAttribute("startNew");
            },
            set:function (value) {
                this.setAttribute(value, "startNew");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        targetType:{
            get:function () {
                return this.getAttribute("targetType");
            },
            set:function (value) {
                this.setAttribute(value, "targetType");
            }
        },
        trailer:{
            get:function () {
                return this.getAttribute("trailer");
            },
            set:function (value) {
                this.setAttribute(value, "trailer");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Button = xfalib.script.dom.Button = xfalib.script.DOMElement.extend({
        msClassName:"button"
    });

    Button.defineProps({
        highlight:{
            get:function () {
                return this.getAttribute("highlight");
            },
            set:function (value) {
                this.setAttribute(value, "highlight");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Calculate = xfalib.script.dom.Calculate = xfalib.script.DOMElement.extend({
        msClassName:"calculate"
    });

    Calculate.defineProps({
        override:{
            get:function () {
                return this.getAttribute("override");
            },
            set:function (value) {
                this.setAttribute(value, "override");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        message:{
            get:function () {
                return this.getElement("message", 0);
            },
            set:function (value) {
                this.setElement(value, "message");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Caption = xfalib.script.dom.Caption = xfalib.script.DOMElement.extend({
        msClassName:"caption"
    });

    Caption.defineProps({
        placement:{
            get:function () {
                return this.getAttribute("placement");
            },
            set:function (value) {
                this.setAttribute(value, "placement");
            }
        },
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
            }
        },
        reserve:{
            get:function () {
                return this.getAttribute("reserve");
            },
            set:function (value) {
                this.setAttribute(value, "reserve");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        font:{
            get:function () {
                return this.getElement("font", 0);
            },
            set:function (value) {
                this.setElement(value, "font");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        },
        para:{
            get:function () {
                return this.getElement("para", 0);
            },
            set:function (value) {
                this.setElement(value, "para");
            }
        },
        value:{
            get:function () {
                return this.getElement("value", 0);
            },
            set:function (value) {
                this.setElement(value, "value");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Certificate = xfalib.script.dom.Certificate = xfalib.script.GenericText.extend({
        msClassName:"certificate"
    });

    Certificate.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var Certificates = xfalib.script.dom.Certificates = xfalib.script.DOMElement.extend({
        msClassName:"certificates"
    });

    Certificates.defineProps({
        credentialServerPolicy:{
            get:function () {
                return this.getAttribute("credentialServerPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "credentialServerPolicy");
            }
        },
        url:{
            get:function () {
                return this.getAttribute("url");
            },
            set:function (value) {
                this.setAttribute(value, "url");
            }
        },
        urlPolicy:{
            get:function () {
                return this.getAttribute("urlPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "urlPolicy");
            }
        },
        encryption:{
            get:function () {
                return this.getElement("encryption", 0);
            },
            set:function (value) {
                this.setElement(value, "encryption");
            }
        },
        issuers:{
            get:function () {
                return this.getElement("issuers", 0);
            },
            set:function (value) {
                this.setElement(value, "issuers");
            }
        },
        keyUsage:{
            get:function () {
                return this.getElement("keyUsage", 0);
            },
            set:function (value) {
                this.setElement(value, "keyUsage");
            }
        },
        oids:{
            get:function () {
                return this.getElement("oids", 0);
            },
            set:function (value) {
                this.setElement(value, "oids");
            }
        },
        signing:{
            get:function () {
                return this.getElement("signing", 0);
            },
            set:function (value) {
                this.setElement(value, "signing");
            }
        },
        subjectDNs:{
            get:function () {
                return this.getElement("subjectDNs", 0);
            },
            set:function (value) {
                this.setElement(value, "subjectDNs");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var CheckButton = xfalib.script.dom.CheckButton = xfalib.script.DOMElement.extend({
        msClassName:"checkButton"
    });

    CheckButton.defineProps({
        allowNeutral:{
            get:function () {
                return this.getAttribute("allowNeutral");
            },
            set:function (value) {
                this.setAttribute(value, "allowNeutral");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,this,"allowNeutral",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        mark:{
            get:function () {
                return this.getAttribute("mark");
            },
            set:function (value) {
                this.setAttribute(value, "mark");
            }
        },
        shape:{
            get:function () {
                return this.getAttribute("shape");
            },
            set:function (value) {
                this.setAttribute(value, "shape");
            }
        },
        size:{
            get:function () {
                return this.getAttribute("size");
            },
            set:function (value) {
                this.setAttribute(value, "size");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var ChoiceList = xfalib.script.dom.ChoiceList = xfalib.script.DOMElement.extend({
        msClassName:"choiceList"
    });

    ChoiceList.defineProps({
        commitOn:{
            get:function () {
                return this.getAttribute("commitOn");
            },
            set:function (value) {
                this.setAttribute(value, "commitOn");
            }
        },
        open:{
            get:function () {
                return this.getAttribute("open");
            },
            set:function (value) {
                this.setAttribute(value, "open");
            }
        },
        textEntry:{
            get:function () {
                return this.getAttribute("textEntry");
            },
            set:function (value) {
                this.setAttribute(value, "textEntry");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Color = xfalib.script.dom.Color = xfalib.script.DOMElement.extend({
        msClassName:"color"
    });

    Color.defineProps({
        cSpace:{
            get:function () {
                return this.getAttribute("cSpace");
            },
            set:function (value) {
                this.setAttribute(value, "cSpace");
            }
        },
        value:{
            get:function () {
                return this.getAttribute("value");
            },
            set:function (value) {
                this.setAttribute(value, "value");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"color.value",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Comb = xfalib.script.dom.Comb = xfalib.script.GenericText.extend({
        msClassName:"comb"
    });

    Comb.defineProps({
        numberOfCells:{
            get:function () {
                return this.getAttribute("numberOfCells");
            },
            set:function (value) {
                this.setAttribute(value, "numberOfCells");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Connect = xfalib.script.dom.Connect = xfalib.script.DOMElement.extend({
        msClassName:"connect"
    });

    Connect.defineProps({
        connection:{
            get:function () {
                return this.getAttribute("connection");
            },
            set:function (value) {
                this.setAttribute(value, "connection");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        usage:{
            get:function () {
                return this.getAttribute("usage");
            },
            set:function (value) {
                this.setAttribute(value, "usage");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Corner = xfalib.script.dom.Corner = xfalib.script.DOMElement.extend({
        msClassName:"corner"
    });

    Corner.defineProps({
        inverted:{
            get:function () {
                return this.getAttribute("inverted");
            },
            set:function (value) {
                this.setAttribute(value, "inverted");
            }
        },
        join:{
            get:function () {
                return this.getAttribute("join");
            },
            set:function (value) {
                this.setAttribute(value, "join");
            }
        },
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
            }
        },
        radius:{
            get:function () {
                return this.getAttribute("radius");
            },
            set:function (value) {
                this.setAttribute(value, "radius");
            }
        },
        stroke:{
            get:function () {
                return this.getAttribute("stroke");
            },
            set:function (value) {
                this.setAttribute(value, "stroke");
            }
        },
        thickness:{
            get:function () {
                return this.getAttribute("thickness");
            },
            set:function (value) {
                this.setAttribute(value, "thickness");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var DateTimeEdit = xfalib.script.dom.DateTimeEdit = xfalib.script.DOMElement.extend({
        msClassName:"dateTimeEdit"
    });

    DateTimeEdit.defineProps({
        hScrollPolicy:{
            get:function () {
                return this.getAttribute("hScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "hScrollPolicy");
            }
        },
        picker:{
            get:function () {
                return this.getAttribute("picker");
            },
            set:function (value) {
                this.setAttribute(value, "picker");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        comb:{
            get:function () {
                return this.getElement("comb", 0);
            },
            set:function (value) {
                this.setElement(value, "comb");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var DefaultUi = xfalib.script.dom.DefaultUi = xfalib.script.DOMElement.extend({
        msClassName:"defaultUi"
    });

    DefaultUi.defineProps({
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function(_,xfalib){
    var Desc = xfalib.script.dom.Desc = xfalib.script.DOMElement.extend({
        msClassName: "desc"
    });

})(_,xfalib);
(function (_, xfalib) {
    var DigestMethod = xfalib.script.dom.DigestMethod = xfalib.script.GenericText.extend({
        msClassName:"digestMethod"
    });

    DigestMethod.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var DigestMethods = xfalib.script.dom.DigestMethods = xfalib.script.DOMElement.extend({
        msClassName:"digestMethods"
    });

    DigestMethods.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Edge = xfalib.script.dom.Edge = xfalib.script.DOMElement.extend({
        msClassName:"edge"
    });

    Edge.defineProps({
        cap:{
            get:function () {
                return this.getAttribute("cap");
            },
            set:function (value) {
                this.setAttribute(value, "cap");
            }
        },
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"edge.presence",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        stroke:{
            get:function () {
                return this.getAttribute("stroke");
            },
            set:function (value) {
                this.setAttribute(value, "stroke");
            }
        },
        thickness:{
            get:function () {
                return this.getAttribute("thickness");
            },
            set:function (value) {
                this.setAttribute(value, "thickness");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"edge.thickness",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Encoding = xfalib.script.dom.Encoding = xfalib.script.GenericText.extend({
        msClassName:"encoding"
    });

    Encoding.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var Encodings = xfalib.script.dom.Encodings = xfalib.script.DOMElement.extend({
        msClassName:"encodings"
    });

    Encodings.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Encrypt = xfalib.script.dom.Encrypt = xfalib.script.DOMElement.extend({
        msClassName:"encrypt"
    });

    Encrypt.defineProps({
        certificate:{
            get:function () {
                return this.getElement("certificate", 0);
            },
            set:function (value) {
                this.setElement(value, "certificate");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var EncryptData = xfalib.script.dom.EncryptData = xfalib.script.DOMElement.extend({
        msClassName:"encryptData"
    });

    EncryptData.defineProps({
        operation:{
            get:function () {
                return this.getAttribute("operation");
            },
            set:function (value) {
                this.setAttribute(value, "operation");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        filter:{
            get:function () {
                return this.getElement("filter", 0);
            },
            set:function (value) {
                this.setElement(value, "filter");
            }
        },
        manifest:{
            get:function () {
                return this.getElement("manifest", 0);
            },
            set:function (value) {
                this.setElement(value, "manifest");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Encryption = xfalib.script.dom.Encryption = xfalib.script.DOMElement.extend({
        msClassName:"encryption"
    });

    Encryption.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var EncryptionMethod = xfalib.script.dom.EncryptionMethod = xfalib.script.GenericText.extend({
        msClassName:"encryptionMethod"
    });

})(_, xfalib);
(function (_, xfalib) {
    var EncryptionMethods = xfalib.script.dom.EncryptionMethods = xfalib.script.DOMElement.extend({
        msClassName:"encryptionMethods"
    });

    EncryptionMethods.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Event = xfalib.script.dom.Event = xfalib.script.DOMElement.extend({
        msClassName:"event"
    });

    Event.defineProps({
        activity:{
            get:function () {
                return this.getAttribute("activity");
            },
            set:function (value) {
                this.setAttribute(value, "activity");
            }
        },
        listen:{
            get:function () {
                return this.getAttribute("listen");
            },
            set:function (value) {
                this.setAttribute(value, "listen");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        encryptData:{
            get:function () {
                return this.getElement("encryptData", 0);
            },
            set:function (value) {
                this.setElement(value, "encryptData");
            }
        },
        execute:{
            get:function () {
                return this.getElement("execute", 0);
            },
            set:function (value) {
                this.setElement(value, "execute");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        },
        signData:{
            get:function () {
                return this.getElement("signData", 0);
            },
            set:function (value) {
                this.setElement(value, "signData");
            }
        },
        submit:{
            get:function () {
                return this.getElement("submit", 0);
            },
            set:function (value) {
                this.setElement(value, "submit");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Execute = xfalib.script.dom.Execute = xfalib.script.GenericText.extend({
        msClassName:"execute"
    });

    Execute.defineProps({
        connection:{
            get:function () {
                return this.getAttribute("connection");
            },
            set:function (value) {
                this.setAttribute(value, "connection");
            }
        },
        executeType:{
            get:function () {
                return this.getAttribute("executeType");
            },
            set:function (value) {
                this.setAttribute(value, "executeType");
            }
        },
        runAt:{
            get:function () {
                return this.getAttribute("runAt");
            },
            set:function (value) {
                this.setAttribute(value, "runAt");
            }
        }
    });

})(_, xfalib);
(function(_,xfalib){
    var Extras = xfalib.script.dom.Extras = xfalib.script.DOMElement.extend({
        msClassName: "extras"
    });

})(_,xfalib);
(function (_, xfalib) {
    var Fill = xfalib.script.dom.Fill = xfalib.script.DOMElement.extend({
        msClassName:"fill"
    });

    Fill.defineProps({
        presence:{
            get:function () {
                return this.getAttribute("presence");
            },
            set:function (value) {
                this.setAttribute(value, "presence");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"fill.presence",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        linear:{
            get:function () {
                return this.getElement("linear", 0);
            },
            set:function (value) {
                this.setElement(value, "linear");
            }
        },
        pattern:{
            get:function () {
                return this.getElement("pattern", 0);
            },
            set:function (value) {
                this.setElement(value, "pattern");
            }
        },
        radial:{
            get:function () {
                return this.getElement("radial", 0);
            },
            set:function (value) {
                this.setElement(value, "radial");
            }
        },
        solid:{
            get:function () {
                return this.getElement("solid", 0);
            },
            set:function (value) {
                this.setElement(value, "solid");
            }
        },
        stipple:{
            get:function () {
                return this.getElement("stipple", 0);
            },
            set:function (value) {
                this.setElement(value, "stipple");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Filter = xfalib.script.dom.Filter = xfalib.script.DOMElement.extend({
        msClassName:"filter"
    });

    Filter.defineProps({
        addRevocationInfo:{
            get:function () {
                return this.getAttribute("addRevocationInfo");
            },
            set:function (value) {
                this.setAttribute(value, "addRevocationInfo");
            }
        },
        version:{
            get:function () {
                return this.getAttribute("version");
            },
            set:function (value) {
                this.setAttribute(value, "version");
            }
        },
        appearanceFilter:{
            get:function () {
                return this.getElement("appearanceFilter", 0);
            },
            set:function (value) {
                this.setElement(value, "appearanceFilter");
            }
        },
        certificates:{
            get:function () {
                return this.getElement("certificates", 0);
            },
            set:function (value) {
                this.setElement(value, "certificates");
            }
        },
        digestMethods:{
            get:function () {
                return this.getElement("digestMethods", 0);
            },
            set:function (value) {
                this.setElement(value, "digestMethods");
            }
        },
        encodings:{
            get:function () {
                return this.getElement("encodings", 0);
            },
            set:function (value) {
                this.setElement(value, "encodings");
            }
        },
        encryptionMethods:{
            get:function () {
                return this.getElement("encryptionMethods", 0);
            },
            set:function (value) {
                this.setElement(value, "encryptionMethods");
            }
        },
        handler:{
            get:function () {
                return this.getElement("handler", 0);
            },
            set:function (value) {
                this.setElement(value, "handler");
            }
        },
        lockDocument:{
            get:function () {
                return this.getElement("lockDocument", 0);
            },
            set:function (value) {
                this.setElement(value, "lockDocument");
            }
        },
        mdp:{
            get:function () {
                return this.getElement("mdp", 0);
            },
            set:function (value) {
                this.setElement(value, "mdp");
            }
        },
        reasons:{
            get:function () {
                return this.getElement("reasons", 0);
            },
            set:function (value) {
                this.setElement(value, "reasons");
            }
        },
        timeStamp:{
            get:function () {
                return this.getElement("timeStamp", 0);
            },
            set:function (value) {
                this.setElement(value, "timeStamp");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Font = xfalib.script.dom.Font = xfalib.script.DOMElement.extend({
        msClassName:"font"
    });

    Font.defineProps({
        baselineShift:{
            get:function () {
                return this.getAttribute("baselineShift");
            },
            set:function (value) {
                this.setAttribute(value, "baselineShift");
            }
        },
        fontHorizontalScale:{
            get:function () {
                return this.getAttribute("fontHorizontalScale");
            },
            set:function (value) {
                this.setAttribute(value, "fontHorizontalScale");
            }
        },
        fontVerticalScale:{
            get:function () {
                return this.getAttribute("fontVerticalScale");
            },
            set:function (value) {
                this.setAttribute(value, "fontVerticalScale");
            }
        },
        kerningMode:{
            get:function () {
                return this.getAttribute("kerningMode");
            },
            set:function (value) {
                this.setAttribute(value, "kerningMode");
            }
        },
        letterSpacing:{
            get:function () {
                return this.getAttribute("letterSpacing");
            },
            set:function (value) {
                this.setAttribute(value, "letterSpacing");
            }
        },
        lineThrough:{
            get:function () {
                return this.getAttribute("lineThrough");
            },
            set:function (value) {
                this.setAttribute(value, "lineThrough");
            }
        },
        lineThroughPeriod:{
            get:function () {
                return this.getAttribute("lineThroughPeriod");
            },
            set:function (value) {
                this.setAttribute(value, "lineThroughPeriod");
            }
        },
        overline:{
            get:function () {
                return this.getAttribute("overline");
            },
            set:function (value) {
                this.setAttribute(value, "overline");
            }
        },
        overlinePeriod:{
            get:function () {
                return this.getAttribute("overlinePeriod");
            },
            set:function (value) {
                this.setAttribute(value, "overlinePeriod");
            }
        },
        posture:{
            get:function () {
                return this.getAttribute("posture");
            },
            set:function (value) {
                this.setAttribute(value, "posture");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this, "font.posture", value, null);
                this.trigger(evnt.name, evnt);
            }
        },
        size:{
            get:function () {
                return this.getAttribute("size");
            },
            set:function (value) {
                this.setAttribute(value, "size");
            }
        },
        typeface:{
            get:function () {
                return this.getAttribute("typeface");
            },
            set:function (value) {
                this.setAttribute(value, "typeface");
            }
        },
        underline:{
            get:function () {
                return this.getAttribute("underline");
            },
            set:function (value) {
                this.setAttribute(value, "underline");
            }
        },
        underlinePeriod:{
            get:function () {
                return this.getAttribute("underlinePeriod");
            },
            set:function (value) {
                this.setAttribute(value, "underlinePeriod");
            }
        },
        weight:{
            get:function () {
                return this.getAttribute("weight");
            },
            set:function (value) {
                this.setAttribute(value, "weight");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        fill:{
            get:function () {
                return this.getElement("fill", 0);
            },
            set:function (value) {
                this.setElement(value, "fill");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Format = xfalib.script.dom.Format = xfalib.script.DOMElement.extend({
        msClassName:"format"
    });

    Format.defineProps({
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Handler = xfalib.script.dom.Handler = xfalib.script.GenericText.extend({
        msClassName:"handler"
    });

    Handler.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Hyphenation = xfalib.script.dom.Hyphenation = xfalib.script.GenericText.extend({
        msClassName:"hyphenation"
    });

    Hyphenation.defineProps({
        excludeAllCaps:{
            get:function () {
                return this.getAttribute("excludeAllCaps");
            },
            set:function (value) {
                this.setAttribute(value, "excludeAllCaps");
            }
        },
        excludeInitialCap:{
            get:function () {
                return this.getAttribute("excludeInitialCap");
            },
            set:function (value) {
                this.setAttribute(value, "excludeInitialCap");
            }
        },
        hyphenate:{
            get:function () {
                return this.getAttribute("hyphenate");
            },
            set:function (value) {
                this.setAttribute(value, "hyphenate");
            }
        },
        ladderCount:{
            get:function () {
                return this.getAttribute("ladderCount");
            },
            set:function (value) {
                this.setAttribute(value, "ladderCount");
            }
        },
        pushCharacterCount:{
            get:function () {
                return this.getAttribute("pushCharacterCount");
            },
            set:function (value) {
                this.setAttribute(value, "pushCharacterCount");
            }
        },
        remainCharacterCount:{
            get:function () {
                return this.getAttribute("remainCharacterCount");
            },
            set:function (value) {
                this.setAttribute(value, "remainCharacterCount");
            }
        },
        wordCharacterCount:{
            get:function () {
                return this.getAttribute("wordCharacterCount");
            },
            set:function (value) {
                this.setAttribute(value, "wordCharacterCount");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var ImageEdit = xfalib.script.dom.ImageEdit = xfalib.script.DOMElement.extend({
        msClassName:"imageEdit"
    });

    ImageEdit.defineProps({
        data:{
            get:function () {
                return this.getAttribute("data");
            },
            set:function (value) {
                this.setAttribute(value, "data");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Issuers = xfalib.script.dom.Issuers = xfalib.script.DOMElement.extend({
        msClassName:"issuers"
    });

    Issuers.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Items = xfalib.script.dom.Items = xfalib.script.DOMElement.extend({
        _defaults: {
            "save": "0"
        },

        msClassName: "items",
        initialize: function () {
            Items._super.initialize.call(this);
        },

        _computeJsonDiff: function (diff_level) {

            /*
             * always return <items> - bug#3621898
             * In case of final submission, don't send Items
             */
            return diff_level === 2 ? {
                "changed": false,
                jsonDifference: {}
            } : {
                "changed": true,
                jsonDifference: this.jsonModel
            };
        }

    });

    Items.defineProps({
        "save": {
            get: function () {
                return this.getAttribute("save");
            }
        }
    });

    Items.addMixins([
        xfalib.script.mixin.AddPresence
    ]);
})(_, xfalib);

(function (_, xfalib) {
    var Keep = xfalib.script.dom.Keep = xfalib.script.DOMElement.extend({
        msClassName:"keep"
    });

    Keep.defineProps({
        intact:{
            get:function () {
                return this.getAttribute("intact");
            },
            set:function (value) {
                this.setAttribute(value, "intact");
            }
        },
        next:{
            get:function () {
                return this.getAttribute("next");
            },
            set:function (value) {
                this.setAttribute(value, "next");
            }
        },
        previous:{
            get:function () {
                return this.getAttribute("previous");
            },
            set:function (value) {
                this.setAttribute(value, "previous");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var KeyUsage = xfalib.script.dom.KeyUsage = xfalib.script.GenericText.extend({
        msClassName:"keyUsage"
    });

    KeyUsage.defineProps({
        crlSign:{
            get:function () {
                return this.getAttribute("crlSign");
            },
            set:function (value) {
                this.setAttribute(value, "crlSign");
            }
        },
        dataEncipherment:{
            get:function () {
                return this.getAttribute("dataEncipherment");
            },
            set:function (value) {
                this.setAttribute(value, "dataEncipherment");
            }
        },
        decipherOnly:{
            get:function () {
                return this.getAttribute("decipherOnly");
            },
            set:function (value) {
                this.setAttribute(value, "decipherOnly");
            }
        },
        digitalSignature:{
            get:function () {
                return this.getAttribute("digitalSignature");
            },
            set:function (value) {
                this.setAttribute(value, "digitalSignature");
            }
        },
        encipherOnly:{
            get:function () {
                return this.getAttribute("encipherOnly");
            },
            set:function (value) {
                this.setAttribute(value, "encipherOnly");
            }
        },
        keyAgreement:{
            get:function () {
                return this.getAttribute("keyAgreement");
            },
            set:function (value) {
                this.setAttribute(value, "keyAgreement");
            }
        },
        keyCertSign:{
            get:function () {
                return this.getAttribute("keyCertSign");
            },
            set:function (value) {
                this.setAttribute(value, "keyCertSign");
            }
        },
        keyEncipherment:{
            get:function () {
                return this.getAttribute("keyEncipherment");
            },
            set:function (value) {
                this.setAttribute(value, "keyEncipherment");
            }
        },
        nonRepudiation:{
            get:function () {
                return this.getAttribute("nonRepudiation");
            },
            set:function (value) {
                this.setAttribute(value, "nonRepudiation");
            }
        },
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Linear = xfalib.script.dom.Linear = xfalib.script.DOMElement.extend({
        msClassName:"linear"
    });

    Linear.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var LockDocument = xfalib.script.dom.LockDocument = xfalib.script.GenericText.extend({
        msClassName:"lockDocument"
    });

    LockDocument.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Manifest = xfalib.script.dom.Manifest = xfalib.script.DOMElement.extend({
        msClassName:"manifest"
    });

    Manifest.defineProps({
        action:{
            get:function () {
                return this.getAttribute("action");
            },
            set:function (value) {
                this.setAttribute(value, "action");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Margin = xfalib.script.dom.Margin = xfalib.script.DOMElement.extend({
        msClassName:"margin"
    });

    Margin.defineProps({
        bottomInset:{
            get:function () {
                return this.getAttribute("bottomInset");
            },
            set:function (value) {
                this.setAttribute(value, "bottomInset");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"bottomInset",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        leftInset:{
            get:function () {
                return this.getAttribute("leftInset");
            },
            set:function (value) {
                this.setAttribute(value, "leftInset");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"leftInset",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        rightInset:{
            get:function () {
                return this.getAttribute("rightInset");
            },
            set:function (value) {
                this.setAttribute(value, "rightInset");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"rightInset",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        topInset:{
            get:function () {
                return this.getAttribute("topInset");
            },
            set:function (value) {
                this.setAttribute(value, "topInset");
                var evnt = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED,
                    this,"topInset",value, null);
                this.trigger(evnt.name,evnt);
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Mdp = xfalib.script.dom.Mdp = xfalib.script.GenericText.extend({
        msClassName:"mdp"
    });

    Mdp.defineProps({
        permissions:{
            get:function () {
                return this.getAttribute("permissions");
            },
            set:function (value) {
                this.setAttribute(value, "permissions");
            }
        },
        signatureType:{
            get:function () {
                return this.getAttribute("signatureType");
            },
            set:function (value) {
                this.setAttribute(value, "signatureType");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Medium = xfalib.script.dom.Medium = xfalib.script.GenericText.extend({
        msClassName:"medium"
    });

    Medium.defineProps({
        imagingBBox:{
            get:function () {
                return this.getAttribute("imagingBBox");
            },
            set:function (value) {
                this.setAttribute(value, "imagingBBox");
            }
        },
        "long":{
            get:function () {
                return this.getAttribute("long");
            },
            set:function (value) {
                this.setAttribute(value, "long");
            }
        },
        orientation:{
            get:function () {
                return this.getAttribute("orientation");
            },
            set:function (value) {
                this.setAttribute(value, "orientation");
            }
        },
        "short":{
            get:function () {
                return this.getAttribute("short");
            },
            set:function (value) {
                this.setAttribute(value, "short");
            }
        },
        stock:{
            get:function () {
                return this.getAttribute("stock");
            },
            set:function (value) {
                this.setAttribute(value, "stock");
            }
        },
        trayIn:{
            get:function () {
                return this.getAttribute("trayIn");
            },
            set:function (value) {
                this.setAttribute(value, "trayIn");
            }
        },
        trayOut:{
            get:function () {
                return this.getAttribute("trayOut");
            },
            set:function (value) {
                this.setAttribute(value, "trayOut");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Message = xfalib.script.dom.Message = xfalib.script.DOMElement.extend({
        msClassName:"message"
    });

})(_, xfalib);
(function (_, xfalib) {
    var NumericEdit = xfalib.script.dom.NumericEdit = xfalib.script.DOMElement.extend({
        msClassName:"numericEdit"
    });

    NumericEdit.defineProps({
        hScrollPolicy:{
            get:function () {
                return this.getAttribute("hScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "hScrollPolicy");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        comb:{
            get:function () {
                return this.getElement("comb", 0);
            },
            set:function (value) {
                this.setElement(value, "comb");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Occur = xfalib.script.dom.Occur = xfalib.script.DOMElement.extend({
        msClassName:"occur",
        playJson : function(pJsonModel) {

        }

    });

    Occur.defineProps({
        initial:{
            get:function () {
                return this.getAttribute("initial");
            },
            set:function (value) {
                this.setAttribute(value, "initial");
            }
        },
        max:{
            get:function () {
                return this.getAttribute("max");
            },
            set:function (value) {
                this.setAttribute(value, "max");
            }
        },
        min:{
            get:function () {
                return this.getAttribute("min");
            },
            set:function (value) {
                this.setAttribute(value, "min");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Oid = xfalib.script.dom.Oid = xfalib.script.GenericText.extend({
        msClassName:"oid"
    });

})(_, xfalib);
(function (_, xfalib) {
    var Oids = xfalib.script.dom.Oids = xfalib.script.DOMElement.extend({
        msClassName:"oids"
    });

    Oids.defineProps({
        "type":{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Overflow = xfalib.script.dom.Overflow = xfalib.script.GenericText.extend({
        msClassName:"overflow"
    });

    Overflow.defineProps({
        leader:{
            get:function () {
                return this.getAttribute("leader");
            },
            set:function (value) {
                this.setAttribute(value, "leader");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        trailer:{
            get:function () {
                return this.getAttribute("trailer");
            },
            set:function (value) {
                this.setAttribute(value, "trailer");
            }
        }
    });

})(_, xfalib);
(function(_,xfalib){
    var Para = xfalib.script.dom.Para = xfalib.script.DOMElement.extend({
        msClassName:"para"
    });

    Para.defineProps({
        hAlign : {
            get : function(){
                return this.getAttribute("hAlign");
            },
            set : function(value){
                this.setAttribute(value, "hAlign");
            }
        },

        lineHeight : {
            get : function(){
                return this.getAttribute("lineHeight");
            },
            set : function(value){
                this.setAttribute(value, "lineHeight");
            }
        },

        marginLeft : {
            get : function(){
                return this.getAttribute("marginLeft");
            },
            set : function(value){
                this.setAttribute(value, "marginLeft");
            }
        },

        marginRight : {
            get : function(){
                return this.getAttribute("marginRight");
            },
            set : function(value){
                this.setAttribute(value, "marginRight");
            }
        },

        orphans : {
            get : function(){
                return this.getAttribute("orphans");
            },
            set : function(value){
                this.setAttribute(value, "orphans");
            }
        },

        preserve : {
            get : function(){
                return this.getAttribute("preserve");
            },
            set : function(value){
                this.setAttribute(value, "preserve");
            }
        },

        radixOffset : {
            get : function(){
                return this.getAttribute("radixOffset");
            },
            set : function(value){
                this.setAttribute(value, "radixOffset");
            }
        },

        spaceAbove : {
            get : function(){
                return this.getAttribute("spaceAbove");
            },
            set : function(value){
                this.setAttribute(value, "spaceAbove");
            }
        },

        spaceBelow : {
            get : function(){
                return this.getAttribute("spaceBelow");
            },
            set : function(value){
                this.setAttribute(value, "spaceBelow");
            }
        },

        tabDefault : {
            get : function(){
                return this.getAttribute("tabDefault");
            },
            set : function(value){
                this.setAttribute(value, "tabDefault");
            }
        },

        tabStops : {
            get : function(){
                return this.getAttribute("tabStops");
            },
            set : function(value){
                this.setAttribute(value, "tabStops");
            }
        },

        textIndent : {
            get : function(){
                return this.getAttribute("textIndent");
            },
            set : function(value){
                this.setAttribute(value, "textIndent");
            }
        },

        vAlign : {
            get : function(){
                return this.getAttribute("vAlign");
            },
            set : function(value){
                this.setAttribute(value, "vAlign");
            }
        },

        widows : {
            get : function(){
                return this.getAttribute("widows");
            },
            set : function(value){
                this.setAttribute(value, "widows");
            }
        },

        wordSpacingMaximum : {
            get : function(){
                return this.getAttribute("wordSpacingMaximum");
            },
            set : function(value){
                this.setAttribute(value, "wordSpacingMaximum");
            }
        },

        wordSpacingMinimum : {
            get : function(){
                return this.getAttribute("wordSpacingMinimum");
            },
            set : function(value){
                this.setAttribute(value, "wordSpacingMinimum");
            }
        },

        wordSpacingOptimum : {
            get : function(){
                return this.getAttribute("wordSpacingOptimum");
            },
            set : function(value){
                this.setAttribute(value, "wordSpacingOptimum");
            }
        }
    });

})(_,xfalib);


(function (_, xfalib) {
    var PasswordEdit = xfalib.script.dom.PasswordEdit = xfalib.script.DOMElement.extend({
        msClassName:"passwordEdit"
    });

    PasswordEdit.defineProps({
        hScrollPolicy:{
            get:function () {
                return this.getAttribute("hScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "hScrollPolicy");
            }
        },
        passwordChar:{
            get:function () {
                return this.getAttribute("passwordChar");
            },
            set:function (value) {
                this.setAttribute(value, "passwordChar");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Pattern = xfalib.script.dom.Pattern = xfalib.script.DOMElement.extend({
        msClassName:"pattern"
    });

    Pattern.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Picture = xfalib.script.dom.Picture = xfalib.script.GenericText.extend({
        msClassName:"picture"
    });

    Picture.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var Radial = xfalib.script.dom.Radial = xfalib.script.DOMElement.extend({
        msClassName:"radial"
    });

    Radial.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Reason = xfalib.script.dom.Reason = xfalib.script.GenericText.extend({
        msClassName:"reason"
    });

})(_, xfalib);
(function (_, xfalib) {
    var Reasons = xfalib.script.dom.Reasons = xfalib.script.DOMElement.extend({
        msClassName:"reasons"
    });

    Reasons.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Ref = xfalib.script.dom.Ref = xfalib.script.GenericText.extend({
        msClassName:"ref"
    });

    Ref.defineProps({
    });

})(_, xfalib);
(function (_, xfalib) {
    var RenderAs = xfalib.script.dom.RenderAs = xfalib.script.DOMElement.extend({
        msClassName:"renderAs"
    });

    RenderAs.defineProps({
        APIVersion:{
            get:function () {
                return this.getAttribute("APIVersion");
            },
            set:function (value) {
                this.setAttribute(value, "APIVersion");
            }
        },
        svg:{
            get:function () {
                return this.getElement("svg", 0);
            },
            set:function (value) {
                this.setElement(value, "svg");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Script = xfalib.script.dom.Script = xfalib.script.GenericText.extend({
        msClassName:"script"
    });

    Script.defineProps({
        binding:{
            get:function () {
                return this.getAttribute("binding");
            },
            set:function (value) {
                this.setAttribute(value, "binding");
            }
        },
        contentType:{
            get:function () {
                return this.getAttribute("contentType");
            },
            set:function (value) {
                this.setAttribute(value, "contentType");
            }
        },
        runAt:{
            get:function () {
                return this.getAttribute("runAt");
            },
            set:function (value) {
                this.setAttribute(value, "runAt");
            }
        },
        stateless:{
            get:function () {
                return this.getAttribute("stateless");
            },
            set:function (value) {
                this.setAttribute(value, "stateless");
            }
        }
    });

})(_, xfalib);
(function(_, xfalib){
    var ScriptObject = xfalib.script.dom.ScriptObject = xfalib.script.dom.Script.extend({
        msClassName: "script",
        initialize : function(){
            ScriptObject._super.initialize.call(this);
            this._scriptInitialized = false;
        },

        _getNakedThis : function(){
            if(!this._scriptInitialized){
                if(this.value){
                    try{
                        var oldScope = null;
                        if(this.parent.parent instanceof xfalib.script.EventContainerNode) {
                            oldScope = this.parent.parent._createNakedReferencesScope();
                        }
                        this._xfa()._pushContextNode(this);
                        with(this.parent.parent) { // the parent subform of script obj.
                            with(xfalib.runtime) {
                                //TODO: possible xss attack
                                (eval("("+this.value+")")).apply(this.parent.parent,[this]); // subform -> self, this -> baseobj / script Obj
                            }
                        }
                    } catch(exception){
                        var som = this._xfa().moContextNodes[0] ? this._xfa().moContextNodes[0].somExpression
                                                                : ""
                        this._xfa().Logger.error("xfa", xfalib.locale.LogMessages["ALC-FRM-901-015"],
                                                [exception.message, this.name,
                                                 this._xfa().event.name, som])
                    } finally {
                        if(oldScope != null) {
                            this.parent.parent._resetNakedReferencesScope(oldScope);
                        }
                        this._xfa()._popContextNode();
                    }
                }
                this._scriptInitialized = true;
            }
            return this;
        }

    });
})(_, xfalib);
(function (_, xfalib) {
    var SetProperty = xfalib.script.dom.SetProperty = xfalib.script.GenericText.extend({
        msClassName:"setProperty"
    });

    SetProperty.defineProps({
        connection:{
            get:function () {
                return this.getAttribute("connection");
            },
            set:function (value) {
                this.setAttribute(value, "connection");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Signature = xfalib.script.dom.Signature = xfalib.script.DOMElement.extend({
        msClassName:"signature"
    });

    Signature.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        filter:{
            get:function () {
                return this.getElement("filter", 0);
            },
            set:function (value) {
                this.setElement(value, "filter");
            }
        },
        manifest:{
            get:function () {
                return this.getElement("manifest", 0);
            },
            set:function (value) {
                this.setElement(value, "manifest");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var SignData = xfalib.script.dom.SignData = xfalib.script.DOMElement.extend({
        msClassName:"signData"
    });

    SignData.defineProps({
        operation:{
            get:function () {
                return this.getAttribute("operation");
            },
            set:function (value) {
                this.setAttribute(value, "operation");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        filter:{
            get:function () {
                return this.getElement("filter", 0);
            },
            set:function (value) {
                this.setElement(value, "filter");
            }
        },
        manifest:{
            get:function () {
                return this.getElement("manifest", 0);
            },
            set:function (value) {
                this.setElement(value, "manifest");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Signing = xfalib.script.dom.Signing = xfalib.script.DOMElement.extend({
        msClassName:"signing"
    });

    Signing.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Solid = xfalib.script.dom.Solid = xfalib.script.DOMElement.extend({
        msClassName:"solid"
    });

    Solid.defineProps({
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Speak = xfalib.script.dom.Speak = xfalib.script.GenericText.extend({
        msClassName:"speak"
    });

    Speak.defineProps({
        disable:{
            get:function () {
                return this.getAttribute("disable");
            },
            set:function (value) {
                this.setAttribute(value, "disable");
            }
        },
        priority:{
            get:function () {
                return this.getAttribute("priority");
            },
            set:function (value) {
                this.setAttribute(value, "priority");
            }
        },
        rid:{
            get:function () {
                return this.getAttribute("rid");
            },
            set:function (value) {
                this.setAttribute(value, "rid");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Stipple = xfalib.script.dom.Stipple = xfalib.script.DOMElement.extend({
        msClassName:"stipple"
    });

    Stipple.defineProps({
        rate:{
            get:function () {
                return this.getAttribute("rate");
            },
            set:function (value) {
                this.setAttribute(value, "rate");
            }
        },
        color:{
            get:function () {
                return this.getElement("color", 0);
            },
            set:function (value) {
                this.setElement(value, "color");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var SubjectDN = xfalib.script.dom.SubjectDN = xfalib.script.GenericText.extend({
        msClassName:"subjectDN"
    });

    SubjectDN.defineProps({
        delimiter:{
            get:function () {
                return this.getAttribute("delimiter");
            },
            set:function (value) {
                this.setAttribute(value, "delimiter");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var SubjectDNs = xfalib.script.dom.SubjectDNs = xfalib.script.DOMElement.extend({
        msClassName:"subjectDNs"
    });

    SubjectDNs.defineProps({
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Submit = xfalib.script.dom.Submit = xfalib.script.DOMElement.extend({
        msClassName:"submit"
    });

    Submit.defineProps({
        embedPDF:{
            get:function () {
                return this.getAttribute("embedPDF");
            },
            set:function (value) {
                this.setAttribute(value, "embedPDF");
            }
        },
        format:{
            get:function () {
                return this.getAttribute("format");
            },
            set:function (value) {
                this.setAttribute(value, "format");
            }
        },
        target:{
            get:function () {
                return this.getAttribute("target");
            },
            set:function (value) {
                this.setAttribute(value, "target");
            }
        },
        textEncoding:{
            get:function () {
                return this.getAttribute("textEncoding");
            },
            set:function (value) {
                this.setAttribute(value, "textEncoding");
            }
        },
        xdpContent:{
            get:function () {
                return this.getAttribute("xdpContent");
            },
            set:function (value) {
                this.setAttribute(value, "xdpContent");
            }
        },
        encrypt:{
            get:function () {
                return this.getElement("encrypt", 0);
            },
            set:function (value) {
                this.setElement(value, "encrypt");
            }
        }


    });

})(_, xfalib);
(function (_, xfalib) {
    var Svg = xfalib.script.dom.Svg = xfalib.script.GenericText.extend({
        msClassName:"svg"
    });

    Svg.defineProps({
        height:{
            get:function () {
                return this.getAttribute("height");
            },
            set:function (value) {
                this.setAttribute(value, "height");
            }
        },
        viewBox:{
            get:function () {
                return this.getAttribute("viewBox");
            },
            set:function (value) {
                this.setAttribute(value, "viewBox");
            }
        },
        width:{
            get:function () {
                return this.getAttribute("width");
            },
            set:function (value) {
                this.setAttribute(value, "width");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var TextEdit = xfalib.script.dom.TextEdit = xfalib.script.DOMElement.extend({
        msClassName:"textEdit"
    });

    TextEdit.defineProps({
        allowRichText:{
            get:function () {
                return this.getAttribute("allowRichText");
            },
            set:function (value) {
                this.setAttribute(value, "allowRichText");
            }
        },
        hScrollPolicy:{
            get:function () {
                return this.getAttribute("hScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "hScrollPolicy");
            }
        },
        multiLine:{
            get:function () {
                return this.getAttribute("multiLine");
            },
            set:function (value) {
                this.setAttribute(value, "multiLine");
            }
        },
        vScrollPolicy:{
            get:function () {
                return this.getAttribute("vScrollPolicy");
            },
            set:function (value) {
                this.setAttribute(value, "vScrollPolicy");
            }
        },
        border:{
            get:function () {
                return this.getElement("border", 0);
            },
            set:function (value) {
                this.setElement(value, "border");
            }
        },
        comb:{
            get:function () {
                return this.getElement("comb", 0);
            },
            set:function (value) {
                this.setElement(value, "comb");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        margin:{
            get:function () {
                return this.getElement("margin", 0);
            },
            set:function (value) {
                this.setElement(value, "margin");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var TextNode = xfalib.script.TextNode = xfalib.script.Object.extend({
        msClassName:"textNode"
    });

    TextNode.defineProps({

    })
})(_, xfalib);
(function (_, xfalib) {
    var TimeStamp = xfalib.script.dom.TimeStamp = xfalib.script.GenericText.extend({
        msClassName:"timeStamp"
    });

    TimeStamp.defineProps({
        server:{
            get:function () {
                return this.getAttribute("server");
            },
            set:function (value) {
                this.setAttribute(value, "server");
            }
        },
        type:{
            get:function () {
                return this.getAttribute("type");
            },
            set:function (value) {
                this.setAttribute(value, "type");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var ToolTip = xfalib.script.dom.ToolTip = xfalib.script.GenericText.extend({
        msClassName:"toolTip"
    });

    ToolTip.defineProps({
        rid:{
            get:function () {
                return this.getAttribute("rid");
            },
            set:function (value) {
                this.setAttribute(value, "rid");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Traversal = xfalib.script.dom.Traversal = xfalib.script.DOMElement.extend({
        msClassName:"traversal"
    });

    Traversal.defineProps({
        passThrough:{
            get:function () {
                return this.getAttribute("passThrough");
            },
            set:function (value) {
                this.setAttribute(value, "passThrough");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        }

    });

})(_, xfalib);
(function (_, xfalib) {
    var Traverse = xfalib.script.dom.Traverse = xfalib.script.DOMElement.extend({
        msClassName:"traverse"
    });

    Traverse.defineProps({
        delegate:{
            get:function () {
                return this.getAttribute("delegate");
            },
            set:function (value) {
                this.setAttribute(value, "delegate");
            }
        },
        operation:{
            get:function () {
                return this.getAttribute("operation");
            },
            set:function (value) {
                this.setAttribute(value, "operation");
            }
        },
        ref:{
            get:function () {
                return this.getAttribute("ref");
            },
            set:function (value) {
                this.setAttribute(value, "ref");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Ui = xfalib.script.dom.Ui = xfalib.script.DOMElement.extend({
        msClassName:"ui",

        // TODO : remove these once Sharad merges changes from HMRC
        initialize : function(){
            Ui._super.initialize.call(this);
            for (var i = 0; i < this.moChildNodes.length; ++i) {
                var oNode = this.moChildNodes[i];
                oNode.on(xfalib.script.XfaModelEvent.DOM_CHANGED,this) ;
            }
        },

        handleEvent: function(evnt) {
            this.trigger(evnt.name,evnt);
        },

        _getOneOfChild : function(){
            var oneChild = Ui._super._getOneOfChild.call(this);
            if(oneChild)
                return oneChild;

            var childType = "textEdit";
            if(this.parent){
                var valueChild = this.parent.value.oneOfChild || {className : "text"};
                switch (valueChild.className){
                    case "dateTime" :
                    case "date" :
                    case "time" :
                        childType = "dateTimeEdit";
                        break;
                    case "decimal" :
                    case "float" :
                    case "integer" :
                        childType = "numericEdit";
                        break;
                    case "boolean" :
                        childType = "checkButton";
                        break;
                    case "text" :
                        childType = "textEdit";
                        break;
                    case "image" :
                        childType = "imageEdit";
                        break;
                }
            }
            return this._getDefaultElement(childType, 0, true);
        }

    });

    Ui.defineProps({
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        },
        barcode:{
            get:function () {
                return this.getElement("barcode", 0);
            },
            set:function (value) {
                this.setElement(value, "barcode");
            }
        },
        button:{
            get:function () {
                return this.getElement("button", 0);
            },
            set:function (value) {
                this.setElement(value, "button");
            }
        },
        checkButton:{
            get:function () {
                return this.getElement("checkButton", 0);
            },
            set:function (value) {
                this.setElement(value, "checkButton");
            }
        },
        choiceList:{
            get:function () {
                return this.getElement("choiceList", 0);
            },
            set:function (value) {
                this.setElement(value, "choiceList");
            }
        },
        dateTimeEdit:{
            get:function () {
                return this.getElement("dateTimeEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "dateTimeEdit");
            }
        },
        defaultUi:{
            get:function () {
                return this.getElement("defaultUi", 0);
            },
            set:function (value) {
                this.setElement(value, "defaultUi");
            }
        },
        exObject:{
            get:function () {
                return this.getElement("exObject", 0);
            },
            set:function (value) {
                this.setElement(value, "exObject");
            }
        },
        imageEdit:{
            get:function () {
                return this.getElement("imageEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "imageEdit");
            }
        },
        numericEdit:{
            get:function () {
                return this.getElement("numericEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "numericEdit");
            }
        },
        passwordEdit:{
            get:function () {
                return this.getElement("passwordEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "passwordEdit");
            }
        },
        signature:{
            get:function () {
                return this.getElement("signature", 0);
            },
            set:function (value) {
                this.setElement(value, "signature");
            }
        },
        textEdit:{
            get:function () {
                return this.getElement("textEdit", 0);
            },
            set:function (value) {
                this.setElement(value, "textEdit");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Validate = xfalib.script.dom.Validate = xfalib.script.DOMElement.extend({
        msClassName:"validate"
    });

    Validate.defineProps({
        disableAll:{
            get:function () {
                return this.getAttribute("disableAll");
            },
            set:function (value) {
                this.setAttribute(value, "disableAll");
            }
        },
        formatTest:{
            get:function () {
                return this.getAttribute("formatTest");
            },
            set:function (value) {
                this.setAttribute(value, "formatTest");
            }
        },
        nullTest:{
            get:function () {
                return this.getAttribute("nullTest");
            },
            set:function (value) {
                var oldValue = this.nullTest;
                this.setAttribute(value, "nullTest");
                var event = xfalib.script.XfaModelEvent.createEvent(xfalib.script.XfaModelEvent.DOM_CHANGED, this,
                        'nullTest', oldValue, value);
                this.trigger(event.name, event);
            }
        },
        scriptTest:{
            get:function () {
                return this.getAttribute("scriptTest");
            },
            set:function (value) {
                this.setAttribute(value, "scriptTest");
            }
        },
        extras:{
            get:function () {
                return this.getElement("extras", 0);
            },
            set:function (value) {
                this.setElement(value, "extras");
            }
        },
        message:{
            get:function () {
                return this.getElement("message", 0);
            },
            set:function (value) {
                this.setElement(value, "message");
            }
        },
        picture:{
            get:function () {
                return this.getElement("picture", 0);
            },
            set:function (value) {
                this.setElement(value, "picture");
            }
        },
        script:{
            get:function () {
                return this.getElement("script", 0);
            },
            set:function (value) {
                this.setElement(value, "script");
            }
        }
    });

})(_, xfalib);
(function (_, xfalib) {
    var Value = xfalib.script.dom.Value = xfalib.script.DOMElement.extend({
        msClassName: "value",

        _getOneOfChild: function () {
            var oneChild = Value._super._getOneOfChild.call(this);
            if (oneChild)
                return oneChild;

            var childType = "text";
            if (this.parent && (this.parent.className == "field" || this.parent.className == "draw")) {
                /*
                 * Bug:3600246
                 * When checking ui oneOfChild, do not directly use ui.oneOfChild since it would again fallback to value.onOfChild in case value is also missing.
                 * So check json instead and see if ui oneOfChild exist and then only access it.
                 */
                var uiChild = this.xfaUtil().getUiOneOfChildTag(this.parent.jsonModel) ? this.parent.ui.oneOfChild : {className: "text"};
                switch (uiChild.className) {
                    case "numericEdit" :
                        childType = "float";
                        break;
                    case "dateTimeEdit" :
                        childType = "dateTime";
                        break;
                    case "imageEdit" :
                        childType = "image";
                        break;
                    case "textEdit" :
                        if (uiChild.allowRichText) {
                            childType = "exData";
                        }
                        else {
                            childType = "text";
                        }
                        break;
                    case "choiceList" :
                        if (uiChild.open == "multiSelect") {
                            childType = "exData";
                        }
                        else {
                            childType = "text";
                        }
                        break;
                }
            }
            return this._getDefaultElement(childType, 0, true);
        },

        _computeJsonDiff: function (diff_level) {

            //Force all the descendants of value irrespective of submit call
            var diffObj = xfalib.ut.XfaUtil.prototype.stripOrCall.call(this, false, Value._super._computeJsonDiff, [0]);

            //now strip all the EXTRA properties from value if it is final submission  or restoreFormState
            if (diff_level>0 && this.getOrElse(diffObj, 'jsonDifference.children.length', 0)) {
                //believe me this is not that costly as it looks to be as there will be only one child in all the differences and only two keys per child
                var blacklisted = ['extras'];
                diffObj.jsonDifference.children = _.map(diffObj.jsonDifference.children, function (child) {
                    var copy = {};
                    _.each(Object.keys(child), function (key) {
                        if (!_.contains(blacklisted, key)) {
                            copy[key] = child[key];
                        }
                    });
                    return copy;
                }, this);
            }

            //LC-8319 : don't send [] in diffObj.jsonDifference.children
            if (diffObj.jsonDifference && _.every(diffObj.jsonDifference.children, _.isEmpty)) {  // diffObj should have a jsonDifference member
                diffObj.jsonDifference.children = undefined; // scary to use delete due to perf. impact
            }
            return diffObj;
        }

    });

    Value.defineProps({
        override: {
            get: function () {
                return this.getAttribute("override");
            },
            set: function (value) {
                this.setAttribute(value, "override");
            }
        },
        relevant: {
            get: function () {
                return this.getAttribute("relevant");
            },
            set: function (value) {
                this.setAttribute(value, "relevant");
            }
        },
        arc: {
            get: function () {
                return this.getElement("arc", 0);
            },
            set: function (value) {
                this.setElement(value, "arc");
            }
        },
        "boolean": {
            get: function () {
                return this.getElement("boolean", 0);
            },
            set: function (value) {
                this.setElement(value, "boolean");
            }
        },
        "date": {
            get: function () {
                return this.getElement("date", 0);
            },
            set: function (value) {
                this.setElement(value, "date");
            }
        },
        "dateTime": {
            get: function () {
                return this.getElement("dateTime", 0);
            },
            set: function (value) {
                this.setElement(value, "dateTime");
            }
        },
        "decimal": {
            get: function () {
                return this.getElement("decimal", 0);
            },
            set: function (value) {
                this.setElement(value, "decimal");
            }
        },
        exData: {
            get: function () {
                return this.getElement("exData", 0);
            },
            set: function (value) {
                this.setElement(value, "exData");
            }
        },
        "float": {
            get: function () {
                return this.getElement("float", 0);
            },
            set: function (value) {
                this.setElement(value, "float");
            }
        },
        "image": {
            get: function () {
                return this.getElement("image", 0);
            },
            set: function (value) {
                this.setElement(value, "image");
            }
        },
        "integer": {
            get: function () {
                return this.getElement("integer", 0);
            },
            set: function (value) {
                this.setElement(value, "integer");
            }
        },
        line: {
            get: function () {
                return this.getElement("line", 0);
            },
            set: function (value) {
                this.setElement(value, "line");
            }
        },
        rectangle: {
            get: function () {
                return this.getElement("rectangle", 0);
            },
            set: function (value) {
                this.setElement(value, "rectangle");
            }
        },
        "text": {
            get: function () {
                return this.getElement("text", 0);
            },
            set: function (value) {
                this.setElement(value, "text");
            }
        },
        "time": {
            get: function () {
                return this.getElement("time", 0);
            },
            set: function (value) {
                this.setElement(value, "time");
            }
        }
    });

})(_, xfalib);

(function(_, $, xfalib){

    var HtmlTemplateCache = xfalib.view.util.HtmlTemplateCache = xfalib.ut.Class.extend({
        initialize : function(){
            HtmlTemplateCache._super.initialize.call(this);
            this._cache = {};
            this._hiddenObjPages = [];
        },

        put: function (el) {
            var occurIndex = this.getOrElse(this.xfaUtil().$data(el, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL + "." + xfalib.view.LayoutConst.OCCUR_INDEX, '0');
            if (!this.contains(el.id) || this._cache[el.id][occurIndex] === undefined) {
                this._cache[el.id] = this._cache[el.id] || {};
                this._cache[el.id][occurIndex] = el; // the cache is now 2D, against each el id store a map, indexed by occur index
                this._cacheChildren(el);
            }
        },

        contains : function(elId){
            return (this._cache.hasOwnProperty(elId) && this._cache[elId] !== undefined);
        },

        get : function(elId, lookUpHiddenCache){
            var $nodeDiv = null,
                nodeXfaModel = null,
                partOffsetY = 0,
                $pageDiv,
                $splitPart;

            function stitchNodes() {
                // We need to collect all parts of this node from various pages/occurrences and stitch them together.
                // We start by picking *stitched* children of this part and append them to initially empty $nodeDiv. As we move on to next
                // part, we'll pick only those children which starts from that part(occurIndex:0)
                // Stitching would require modify the extenty of children to add content height of current stitched
                // part and then modify the extenth of currently stitched part to include height of new part. All the children from new part are cloned-appended into
                // current stitch part.

                if (!$nodeDiv) {
                    //do not modify existing node. Work on it's clone and start building from scratch.
                    $nodeDiv = $splitPart.clone();
                    $nodeDiv.children().remove();
                    nodeXfaModel = this.xfaUtil().$data($nodeDiv.get(0), xfalib.view.LayoutConst.XFA_MODEL);
                }
                else {
                    partOffsetY = parseFloat(nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_H]) -
                        parseFloat(this.getOrElse(nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.MARGIN_TOP], 0)) -
                        parseFloat(this.getOrElse(nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.MARGIN_BOTTOM], 0));
                }

                _.each($splitPart.children().get(),
                    function (partChild) {
                        var childId = partChild.id;
                        var childHasSplit = (this.getOrElse(this.xfaUtil().$data(partChild, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL + "." + xfalib.view.LayoutConst.OCCURRENCES, 1) > 1);
                        var isChildFirstSplit = (this.getOrElse(this.xfaUtil().$data(partChild, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL + "." + xfalib.view.LayoutConst.OCCUR_INDEX, 0) == 0);
                        var $childClone = null;
                        if (childHasSplit && !isChildFirstSplit) {
                            //split child would already been handled when it's first part was found.
                            return;
                        }
                        else if (childHasSplit && isChildFirstSplit) {
                            //If this child has split and it is first part of the child split, get the entire stitched child.
                            $childClone = $(this.get(childId, true));
                        }
                        else {
                            $childClone = $(partChild).clone();
                        }
                        var childXfaModel = this.xfaUtil().$data($childClone.get(0), xfalib.view.LayoutConst.XFA_MODEL);
                        if (childXfaModel) {
                            // modify the extenty of child and then append this child clone to current stitch part $nodeDiv
                            childXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_Y] = partOffsetY + parseFloat(this.getOrElse(childXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_Y], 0));
                            $childClone.attr("data-" + xfalib.view.LayoutConst.XFA_MODEL, JSON.stringify(childXfaModel));
                        }
                        $childClone.appendTo($nodeDiv);
                    },
                    this
                );

                // modify the extenth part $nodeDiv
                nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_H] = parseFloat(this.xfaUtil().$data($splitPart.get(0), xfalib.view.LayoutConst.XFA_MODEL)[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.EXTENT_H]) + partOffsetY;
            }

            if(this.contains(elId)) {
                if(_.keys(this._cache[elId]).length === 1) {
                    return this._cache[elId]["0"].cloneNode(true);
                }
                // subform was split into different parts, stitch each part in order of occurIndex
                for (var occurIndex = 0; occurIndex < _.keys(this._cache[elId]).length; ++occurIndex) {
                    $splitPart = $(this._cache[elId][occurIndex]);
                    stitchNodes.call(this);
                }

                if ($nodeDiv && $nodeDiv.get(0)) {
                // update stitched node in cache, after modifying occurrences and occur index to make it appear as unsplit
                    this._cache[elId] = undefined;
                    nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.OCCURRENCES] = "1";
                    nodeXfaModel[xfalib.view.LayoutConst.LAYOUT_MODEL][xfalib.view.LayoutConst.OCCUR_INDEX] = undefined;
                }
            }
            else if(lookUpHiddenCache) {
                for(var i = 0; i < this._hiddenObjPages.length; ++i) {
                    $pageDiv = $(this._hiddenObjPages[i]);
                    $splitPart = $pageDiv.find(this.jqId(elId));
                    if($splitPart && $splitPart.get(0)){
                        stitchNodes.call(this);
                    }
                    this._hiddenObjPages[i] = $pageDiv.get(0); // cache the constructed page dom back in hidden objects array in case page was string as it happens for the first time.
                }
            }

            if ($nodeDiv && $nodeDiv.get(0)) {
                $nodeDiv.attr("data-" + xfalib.view.LayoutConst.XFA_MODEL, JSON.stringify(nodeXfaModel));
                this.put($nodeDiv.get(0));  //put it in the cache.
                return $nodeDiv.get(0).cloneNode(true);
            }
            else {
                return null;
            }
        },

        setHiddenObjPages : function(hiddenPages){
            this._hiddenObjPages = hiddenPages || [];
        },

        _cacheChildren : function(parent){
            var that = this;
            $(parent).children().each(function(){
                //cache xfa sub elements as well.
                if(that.getOrElse(that.xfaUtil().$data(this, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.NODE_TYPE, "").length > 0){
                    that.put(this);
                }
            });
        }
    });
})(_, $, xfalib);
(function(_,xfalib) {
    var Constants = {
        XFA_MODEL : "x",
        NODE_TYPE : "t",
        LAYOUT_MODEL: "l",
        SUBFORM_LAYOUT: "sl",
        EXTENT_X : "x",
        EXTENT_Y : "y",
        EXTENT_W : "w",
        EXTENT_H : "h",
        EXTENT_MIN_H : "nh",
        EXTENT_MIN_W : "nw",
        EXTENT_MAX_H : "xh",
        EXTENT_MAX_W : "xw",
        EXTENT_ACTUAL_H : "ah",
        EXTENT_ACTUAL_W : "aw",
        MARGIN_TOP : "t",
        MARGIN_LEFT : "l",
        MARGIN_BOTTOM : "b",
        MARGIN_RIGHT : "r",

        BORDER_TOP : "bt",
        BORDER_LEFT : "bl",
        BORDER_BOTTOM : "bb",
        BORDER_RIGHT : "br",

        COL_SPAN : "c",
        ROW_SPAN : "rs",
        OCCURRENCES : "o",
        OCCUR_INDEX: "i",
        COLUMN_WIDTHS : "cw",
        PAGE_NUMBER: "pn",
        CAP_PLACEMENT : "p",
        LAYOUT_LEFTRIGHTTOPBOTTOM : "lr",
        LAYOUT_RIGHTLEFTTOPBOTTOM : "rl",
        LAYOUT_TOPBOTTOM : "tb",
        LAYOUT_TABLE : "t",
        LAYOUT_ROW : "r",
        LAYOUT_RIGHTLEFTROW : "rr",
        LAYOUT_DATATABLE : "dt"
    };
    xfalib.view.LayoutConst = Constants;
})(_,xfalib);
(function(_, $, xfalib){
    var LayoutBase = xfalib.view.layout.LayoutBase = xfalib.ut.Class.extend({
        initialize : function(){
            xfalib.ut.Class.prototype.initialize.apply(this, arguments);
            this._layoutManager = this._xfaViewRegistry().layoutManager();
            this.target = this.options.target; //ContainerView instance
            this._positioningCssPropertyX = "left";
            this._positioningCssPropertyY = "top";
        },

        measureSize : function(){
            return xfalib.view.BaseView.prototype.measureSize.apply(this.target, arguments);
        },

        invalidateSize : function(){
            return xfalib.view.BaseView.prototype.invalidateSize.apply(this.target, arguments);
        },

        updateDisplay : function(){
            xfalib.view.BaseView.prototype.updateDisplay.apply(this.target, arguments);
            _.each(this.target._normalizedChildViews(), function(childView, index){
                var extent = {};
                extent[this._positioningCssPropertyX] =  childView.layoutModel.measuredx;
                extent[this._positioningCssPropertyY] =  childView.layoutModel.measuredy;
                this.$css(childView.el, extent);
            }, this);
        },

        _targetPaddingX : function(){
            return this.target._padLeft();
        },

        _targetPaddingY : function(){
            return this.target._padTop();
        },

        $data : xfalib.ut.XfaUtil.prototype.$data,

        $css : xfalib.ut.XfaUtil.prototype.$css,

        _xfaViewRegistry : function() {
            return window.xfaViewRegistry;    //TODO: remove window dependency
        }

    })

})(_, $, xfalib);


(function(_, $, xfalib){
    xfalib.view.layout.PositionLayout = xfalib.view.layout.LayoutBase.extend({
        initialize : function(){
            xfalib.view.layout.LayoutBase.prototype.initialize.apply(this, arguments);
        },

        measureSize : function(){
            var layoutModel = this.target.layoutModel;
            var parentPadLeft = this._targetPaddingX();
            var parentPadTop = this._targetPaddingY();
            var oldExtentW = layoutModel.extentw;
            var oldExtentH = layoutModel.extenth;
            var containerW = 0;
            var containerH = 0;
            _.each(this.target._normalizedChildViews(), function(childView, index){

                childView.layoutModel.measuredx =  parentPadLeft + childView.layoutModel.extentx;
                childView.layoutModel.measuredy =  parentPadTop + childView.layoutModel.extenty;
                if(childView.layoutModel.extentx + childView.layoutModel.extentw > containerW)
                    containerW = childView.layoutModel.extentx + childView.layoutModel.extentw;
                if(childView.layoutModel.extenty + childView.layoutModel.extenth > containerH)
                    containerH = childView.layoutModel.extenty + childView.layoutModel.extenth;
            }, this);

            if(layoutModel.extentactualw < 0){
                var parentExtentW = layoutModel.marginleft + containerW + layoutModel.marginright;
                layoutModel.extentw = parentExtentW;
            }
            if(layoutModel.extentactualh < 0){
                var parentExtentH = layoutModel.margintop + containerH + layoutModel.marginbottom;
                layoutModel.extenth = parentExtentH;
            }

            if(oldExtentW != layoutModel.extentw || oldExtentH != layoutModel.extenth){
                return true;
            }
            else {
                return false;
            }
        }

    })
})(_, $, xfalib);



(function(_, $, xfalib){
    xfalib.view.layout.LeftRightLayout = xfalib.view.layout.LayoutBase.extend({
        initialize : function(){
            xfalib.view.layout.LayoutBase.prototype.initialize.apply(this, arguments);
        },

        measureSize : function(){
            var layoutModel = this.target.layoutModel;
            var parentPadX = this._targetPaddingX();
            var parentPadY = this._targetPaddingY();
            var oldExtentW = layoutModel.extentw;
            var oldExtentH = layoutModel.extenth;
            var parentContentWidth  =  layoutModel.extentw - layoutModel.marginleft - layoutModel.marginright + this._layoutManager.LAYOUT_ERROR_MARGIN;
            if(layoutModel.extentactualw < 0){
                parentContentWidth = 1000000; //Arbitrary limitation for max width. Could be MAX_VALUE, but that may be costly?
            }

            var currentX =  0;//Right of the last element
            var currentLineY = 0;
            var lineHeight = 0; //Line Height for current line
            _.each(this.target._normalizedChildViews(), function(childView, index){
                if(currentX + childView.layoutModel.extentw > parentContentWidth){
                    currentX = 0;
                    currentLineY = currentLineY + lineHeight;
                    lineHeight = 0;
                }
                childView.layoutModel.measuredx =  parentPadX + currentX;
                childView.layoutModel.measuredy = parentPadY + currentLineY;
                if(lineHeight < childView.layoutModel.extenth){
                    lineHeight = childView.layoutModel.extenth;
                }
                //update top variables for second element
                currentX = currentX +  childView.layoutModel.extentw;
            }, this);
            if(layoutModel.extentactualw < 0) {
                var parentExtentW = layoutModel.marginleft + currentX + layoutModel.marginright;
                layoutModel.extentw = parentExtentW;
            }
            if(layoutModel.extentactualh < 0) {
                var parentExtentH = layoutModel.margintop + currentLineY + lineHeight + layoutModel.marginbottom;
                layoutModel.extenth = parentExtentH;
            }

            if(oldExtentW != layoutModel.extentw || oldExtentH != layoutModel.extenth){
                return true;
            }
            else{
                return false;
            }
        }

    })
})(_, $, xfalib);

(function(_, $, xfalib){
    xfalib.view.layout.RightLeftLayout = xfalib.view.layout.LeftRightLayout.extend({
        initialize : function(){
            xfalib.view.layout.LeftRightLayout.prototype.initialize.apply(this, arguments);
            this._positioningCssPropertyX = "right";
            this._positioningCssPropertyY = "top";
        },

        _targetPaddingX : function(){
            return this.target._padRight();
        },

        _targetPaddingY : function(){
            return this.target._padTop();
        }

    })
})(_, $, xfalib);


(function(_, $, xfalib){
    xfalib.view.layout.TopBottomLayout = xfalib.view.layout.LayoutBase.extend({

        measureSize : function(){
            var layoutModel = this.target.layoutModel;
            var parentPadLeft = this._targetPaddingX();
            var parentPadTop = this._targetPaddingY();
            var oldExtentW = layoutModel.extentw;
            var oldExtentH = layoutModel.extenth;
            var containerW = 0;
            var currentLineY  =  0;
            _.each(this.target._normalizedChildViews(), function(childView, index){
                childView.layoutModel.measuredx = parentPadLeft;
                childView.layoutModel.measuredy =  parentPadTop + currentLineY;
                if(childView.layoutModel.extentw > containerW) {
                    containerW = childView.layoutModel.extentw;
                }
                //update currentLineY variables for second element
                currentLineY = currentLineY + childView.layoutModel.extenth;
            }, this);

            if(layoutModel.extentactualw < 0){
                var parentExtentW = layoutModel.marginleft + containerW + layoutModel.marginright;
                layoutModel.extentw = parentExtentW;
            }
            if(layoutModel.extentactualh < 0){
                var parentExtentH = layoutModel.margintop + currentLineY + layoutModel.marginbottom;
                layoutModel.extenth = parentExtentH;
            }

            if(oldExtentW != layoutModel.extentw || oldExtentH != layoutModel.extenth){
                return true;
            }
            else {
                return false;
            }
        }

    })
})(_, $, xfalib);


(function(_, $, xfalib){
    xfalib.view.layout.RowLayout = xfalib.view.layout.LayoutBase.extend({
        initialize : function(){
            xfalib.view.layout.LayoutBase.prototype.initialize.apply(this, arguments);
        },

        measureSize : function(){
            var layoutModel = this.target.layoutModel;
            var lineHeight = 0; //Line Height for current line
            _.each(this.target._normalizedChildViews(), function(childView, index){
//                if(childView.model && childView.model.className == "draw")      //Draw table cells are set to 100% sizes. They can not grow. If moved, they'll overlay border
//                    return;
                if(lineHeight < childView.layoutModel.extenth){
                    lineHeight = childView.layoutModel.extenth;
                }
            }, this);
            //Set extenth for all row cells
            _.each(this.target._normalizedChildViews(), function(childView, index){
                if(childView.layoutModel.extenth != lineHeight){
                    childView.layoutModel.extenth = lineHeight;
                    childView.invalidateDisplay();
                }
            }, this);

            layoutModel.extenth = layoutModel.margintop + lineHeight + layoutModel.marginbottom;

            //in case of rowLayout measure would always return true which means
            // layout algo of table would always be triggered as row does not have enough data to compute if any column width changed
            return true;
        }

    })
})(_, $, xfalib);


(function(_, $, xfalib){
    xfalib.view.layout.DataTableRowLayout = xfalib.view.layout.RowLayout.extend({
        initialize : function(){
            xfalib.view.layout.RowLayout.prototype.initialize.apply(this, arguments);
        },

        measureSize : function(){
            //in case of rowLayout measure would always return true which means
            // layout algo of table would always be triggered as row does not have enough data to compute if any column width changed
            return true;
        },

        updateDisplay : function(){
            xfalib.view.layout.RowLayout.prototype.updateDisplay.apply(this, arguments);
            this.$css(this.target.el, {"position":"relative"});
            _.each(this.target._normalizedChildViews(), function(childView){
                var extent = {};
                extent["position"] =  "relative";
                this.$css(childView.el, extent);
                if(childView.layoutModel.borderleft > 2) {
                    this.$css(childView.el, {"border-left-width":childView.layoutModel.borderleft/2.0});
                }
                if(childView.layoutModel.bordertop > 2) {
                    this.$css(childView.el, { "border-top-width":childView.layoutModel.bordertop/2.0});
                }
                if(childView.layoutModel.borderbottom > 2) {
                    this.$css(childView.el, {"border-bottom-width":childView.layoutModel.borderbottom/2.0});
                }
                if(childView.layoutModel.borderright > 2) {
                    this.$css(childView.el, {"border-right-width":childView.layoutModel.borderright/2.0});
                }
            }, this);

        }
    })
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.layout.RightLeftRowLayout = xfalib.view.layout.RowLayout.extend({
        initialize : function(){
            xfalib.view.layout.RowLayout.prototype.initialize.apply(this, arguments);
            this._positioningCssPropertyX = "right";
            this._positioningCssPropertyY = "top";
        },

        _targetPaddingX : function(){
            return this.target._padRight();
        },

        _targetPaddingY : function(){
            return this.target._padTop();
        }
    })
})(_, $, xfalib);



(function(_, $, xfalib){
    xfalib.view.layout.TableLayout = xfalib.view.layout.LayoutBase.extend({
        initialize : function(){
            xfalib.view.layout.LayoutBase.prototype.initialize.apply(this, arguments);
            this._tableCellGrid = [ [] ];
            this.assignedColWidths = this.getOrElse(this.target.layoutModel.columnwidths, []);
            this._columnWidths = this.assignedColWidths.slice();
        },

        /**
         * Returns the Rows in the table by filtering out rows from all the child views
         * @returns Array containing the child views that are rows
         * @private
         */
        _getRows : function () {
            return _.filter(this.target._normalizedChildViews(), function (childView) {
                if (childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW
                        || childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) {
                    return true;
                } else {
                    return false;
                }
            }, this);
        },

        measureSize : function () {
            var layoutModel = this.target.layoutModel,
                rowViews = this._getRows();

            this._validCellsInRow(rowViews);

            _.each(rowViews, function(rowView, rowIndex){
                _.each(rowView._normalizedChildViews(), function(cellView){
                    var cellLayout = cellView.layoutModel;
                    var colspan = this.getOrElse(cellLayout.colspan, 1);
                    if(colspan == -1)
                        colspan = this._tableCellGrid.length - cellView.effectiveCellIndex; //if colpan is -1, then set it to remaining grid length
                    var lastCellIndex = cellView.effectiveCellIndex + colspan -1;

                    if(!this._tableCellGrid[lastCellIndex]){
                        var lastNonEmptyColIndex = -1;
                        for(var j = lastCellIndex; j>=0; j-- ){
                            if(this._tableCellGrid[j]){
                                lastNonEmptyColIndex = j;
                                break;
                            }
                        }
                        //lastNonEmptyColIndex can not be -1 here. since it should be at least 0
                        //Now copy fill all previous missing column data with lastNonEmptyCol data
                        for(var k = lastNonEmptyColIndex + 1; k <= lastCellIndex ; k++){
                            this._tableCellGrid[k] = this._tableCellGrid[k-1].splice() ;
                        }
                    }
                    //Now add currentCellView to proper location in cell grid
                    for(var i = cellView.effectiveCellIndex; i <= lastCellIndex;  i++){
                        this._tableCellGrid[i][rowIndex] = cellView;
                    }

                    if(this.assignedColWidths[cellView.effectiveCellIndex] > -1){
                        this._columnWidths[cellView.effectiveCellIndex] = this.assignedColWidths[cellView.effectiveCellIndex];
                        return;
                    }
                    else if(this.getOrElse(cellLayout.colspan, 1) == 1){ // use actual colspan
                        //TODO:check if tableCellIndex maintained properly
                        if(cellLayout.extentw > (this._columnWidths[cellView.effectiveCellIndex] || 0))
                            this._columnWidths[cellView.effectiveCellIndex]  = cellLayout.extentw;
                    }
                }, this);
            }, this);

            //Additional pass to adjust columnWidths for columns with colpsan > 1
            _.each(this._tableCellGrid, function(columnCells, colIndex){
                if(this.assignedColWidths[colIndex] > -1)
                    return;
                var colWidth = this._columnWidths[colIndex];
                _.each(columnCells, function(cellView){
                    var colspan = this.getOrElse(cellView.layoutModel.colspan, "1");
                    if(colspan == -1)
                        colspan = this._tableCellGrid.length - cellView.effectiveCellIndex;
                    //If colspan is one, we have already taken care. if this cell still extends beyond this column, we'll handle it later
                    if( colspan == 1 || ((cellView.effectiveCellIndex + colspan -1) != colIndex))
                        return;
                    //For spanned column, compute the with of the cell that lies in this cloumn.
                    var spannedColWidth = cellView.layoutModel.extentw;
                    for(var l = cellView.effectiveCellIndex; l < colIndex; l++){
                        spannedColWidth = spannedColWidth - this._columnWidths[l];
                    }
                    if(spannedColWidth > this._columnWidths[colIndex])
                        this._columnWidths[colIndex] = spannedColWidth;
                }, this);
            }, this);

            //Now update the final computed extentw for cells and rows.
            //Also update measuredx/y for it's cells
            _.each(rowViews, function(rowView, rowIndex){
                var rowPadX = rowView.layout._targetPaddingX();
                var rowPadY = rowView.layout._targetPaddingY();
                var rowWidth = 0;
                _.each(rowView._normalizedChildViews(), function(cellView){
                    var newCellW = this._computeColumnWidth(cellView);
                    if(newCellW != cellView.layoutModel.extentw){
                        cellView.layoutModel.extentw = newCellW;
                        cellView.invalidateDisplay();
                    }
                    cellView.layoutModel.measuredx = rowPadX + rowWidth;
                    cellView.layoutModel.measuredy = rowPadY;
                    rowWidth = rowWidth + cellView.layoutModel.extentw;
                }, this);
                var newRowWidth = rowView.layoutModel.marginleft + rowWidth + rowView.layoutModel.marginright;
                if(rowView.layoutModel.extentw != newRowWidth){
                    rowView.layoutModel.extentw = newRowWidth;
                    rowView.invalidateDisplay();
                }
            }, this);

            //Now update the final computed extentw for table and measuredx/y for it's children
            var tablePadX = this._targetPaddingX();
            var tablePadY = this._targetPaddingY();
            var parentW = 0;
            var parentH = 0;
            _.each(this.target._normalizedChildViews(), function(childView, childIndex){
                if(childView.layoutModel.extentw > parentW){
                    parentW = childView.layoutModel.extentw;
                }
                childView.layoutModel.measuredx = tablePadX;
                childView.layoutModel.measuredy = tablePadY + parentH;
                parentH = parentH + childView.layoutModel.extenth;
            }, this);

            var oldExtentW = layoutModel.extentw;
            var oldExtentH = layoutModel.extenth;
            layoutModel.extentw = layoutModel.marginleft + parentW + layoutModel.marginright;
            layoutModel.extenth = layoutModel.margintop + parentH + layoutModel.marginbottom;
            if(oldExtentW != layoutModel.extentw || oldExtentH != layoutModel.extenth){
                return true;
            }
            else {
                return false;
            }
        },

        _computeColumnWidth : function(cellView){
            var colspan = this.getOrElse(cellView.layoutModel.colspan, 1);
            if(colspan <0){
                colspan = this._columnWidths.length - cellView.tableCellIndex;
            }
            if(cellView.effectiveCellIndex + colspan -1 >= this._columnWidths.length)
                return cellView.layoutModel.extentw;              //should not be the case ever
            else{
                var colWidth = 0;
                for(var i= cellView.effectiveCellIndex; i <= cellView.effectiveCellIndex + colspan -1; i++){
                    colWidth = colWidth + this._columnWidths[i];
                }
                return colWidth;
            }
        },

        _validCellsInRow : function(rowViews) {
            var hiddenChildIndex;
            var index;
            var count =0;

            _.each(rowViews, function(rowView, rowIndex){
                var ChildViews = rowView.childViews;
                hiddenChildIndex = [];
                _.each(ChildViews,function(vChildView, index){
                       if(vChildView.model.presence != "visible") {
                          hiddenChildIndex.push(index);  // keeps the index of hidden fields
                       }
                  },this);


                  for(var i=ChildViews.length-1;i>0;i--) {
                     count = 0;
                     _.each(hiddenChildIndex,function(value,index){ // this is to find the number of hidden elements before the given index.
                         if(value < i) count++;
                     },this);
                     ChildViews[i].effectiveCellIndex = ChildViews[i].tableCellIndex - count ; // to calculate the effective cell index for visible fields.
                  }

            },this);
        },

        //layout related functions
        invalidateSize : function(){
            if(!this._layoutManager.isPendingValidateSize(this.target)){ //check isPending to avoid recursion
                _.each(this.target._normalizedChildViews(), function(childView) {
                    if (!this._layoutManager.isPendingValidateSize(childView) && (childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW ||
                            childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW)) {
                        _.each(childView._normalizedChildViews(), function(cellView) {
                            if (!this._layoutManager.isPendingValidateSize(cellView)) {
                                cellView.invalidateSize();
                            }
                        }, this);
                        childView.invalidateSize();
                    }
                }, this);
                xfalib.view.layout.LayoutBase.prototype.invalidateSize.apply(this, arguments);
            }
        }

    })
})(_, $, xfalib);



(function(_, $, xfalib){

    xfalib.view.layout.DataTableLayout = xfalib.view.layout.TableLayout.extend({

        //for a given id get the list of headers (including row-headers and column-headers)
        //this can be multiple in case we have multiple row/column, or cell spans multiple columns
        //TCH: Table Column Header
        //TRH: Table Row Header
        //TDC: Table Data Cell
        getHeader:function(cellId,dataPresenceTable) {
            // use headers as a Set
            var headers = {};
            _.each(dataPresenceTable, function(row, i) {
                _.each(dataPresenceTable[i], function(column, j) {
                    if(cellId == dataPresenceTable[i][j].substring(4)) {
                        var k, header;
                        for(k=0;k<i;k++) {
                            if(dataPresenceTable[k][j].indexOf("TCH:") == 0) {
                                header = dataPresenceTable[k][j].substring(4);
                                if(!headers.hasOwnProperty(header)) {
                                    headers[header] = true;
                                }
                            }
                        }
                        for(k=0;k<j;k++) {
                            if(dataPresenceTable[i][k].indexOf("TRH:") == 0) {
                                header = dataPresenceTable[i][k].substring(4);
                                if(!headers.hasOwnProperty(header)) {
                                    headers[header] = true;
                                }
                            }
                        }
                    }
                },this);
            },this);
            // convert headers Set into string to be added to headers attribute
            return _.keys(headers).join(" ").trim();
        },


        measureSize: function () {
            //heightTable: contains the height for each row
            //widthTable: contains the width for each cell
            //dataPresenceTable: captures the mapping for header to data cells
            var heightTable = [], widthTable = [], dataPresenceTable = [];

            var layoutModel = this.target.layoutModel;
            //get child of tables which are actually rows
            var rowViews = _.filter(this.target._normalizedChildViews(), function (childView) {
                if (childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW || childView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW)
                    return true;
                else
                    return false;
            }, this);
            this._validCellsInRow(rowViews);

            //identify the number of columns in the table (the first row is the bet to get this as
            // previous row rowspan does not impact it). Add all colspans to get the actual number of columns
            var numColumns = 0;
            _.each(rowViews, function (rowView, rowIndex) {
                _.each(rowView._normalizedChildViews(), function (cellView, cellIndex) {
                    if(rowIndex == 0){
                        numColumns+=this.getOrElse(cellView.layoutModel.colspan, 1);
                    }
                }, this);
                //initilaize the columns to an __empty string, and the end of processing table will not
                //contain any __empty cells
                dataPresenceTable[rowIndex] = [];
                for(var i=0;i<numColumns;i++) {
                    dataPresenceTable[rowIndex][i] = "__empty";
                }
            },this);


            //Populate the dataPresenceTable with the IDs for header and data cell - required to associate the headers
            // with the data cells. Also populate the height tables needed for formatting the table.
            _.each(rowViews, function (rowView, rowIndex) {
                _.each(rowView._normalizedChildViews(), function (cellView, cellIndex) {
                    var cellLayout = cellView.layoutModel;
                    var rowspan = this.getOrElse(cellLayout.rowspan, 1);
                    var colspan = this.getOrElse(cellLayout.colspan, 1);
                    if (colspan == -1) {
                        //if colpan is -1, then set it to remaining grid length
                        colspan = this._tableCellGrid.length - cellView.effectiveCellIndex;
                    }
                    if(rowspan == 1){
                        if(heightTable[rowIndex] == undefined || cellView.layoutModel.extenth > heightTable[rowIndex] ) {
                            heightTable[rowIndex] = cellView.layoutModel.extenth;
                            if(cellView.layoutModel.extenth < cellView.layoutModel.initialh)
                                heightTable[rowIndex] = cellView.layoutModel.initialh;
                        }
                    }
                    var actualColumnIndex = 0;
                    for (var i = 0; i < numColumns; i++) {
                        if(dataPresenceTable[rowIndex][i] == "__empty") {
                            for(var j=0;j<colspan;j++) {
                                for(var k=0;k<rowspan;k++) {
                                    if(cellView.el.nodeName == "TH") {
                                        if(cellView._isPartOfHeaderRow()) {
                                            dataPresenceTable[rowIndex+k][actualColumnIndex+j] = "TCH:"+cellView._id;
                                        } else {
                                            dataPresenceTable[rowIndex+k][actualColumnIndex+j] = "TRH:"+cellView._id;
                                        }
                                    } else {
                                        dataPresenceTable[rowIndex+k][actualColumnIndex+j] = "TDC:"+cellView._id;
                                    }
                                    if(colspan == 1){
                                        if(widthTable[actualColumnIndex] == undefined || cellView.layoutModel.extentw > widthTable[actualColumnIndex] ) {
                                            widthTable[actualColumnIndex] = cellView.layoutModel.extentw;
                                        }
                                    }
                                }
                            }

                            break;
                        } else {
                            actualColumnIndex++;
                        }
                    }
                    layoutModel.extenth = 0;
                    layoutModel.extentw = 0;
                    _.each(heightTable, function(height) {
                        layoutModel.extenth+=height ;
                    });

                    _.each(widthTable, function(width) {
                        layoutModel.extentw+=width;
                    });

                }, this);
            }, this);

            //set the row and cell height from height table to keep all cells symmetric
            //also add the headers attribute to the view
            _.each(rowViews, function (rowView, rowIndex) {
                var rowPadX = rowView.layout._targetPaddingX();
                var rowPadY = rowView.layout._targetPaddingY();
                rowView.layoutModel.extenth =  heightTable[rowIndex];

                //process the info to get row heights, column heights and first cell
                _.each(rowView._normalizedChildViews(), function (cellView, cellIndex) {
                    var headers = this.getHeader(cellView._id,dataPresenceTable);
                    if(headers != "") {
                        cellView.$el.attr('headers', headers);
                    }
                    if(cellView.layoutModel.rowspan == 1) {
                        cellView.layoutModel.extenth =  heightTable[rowIndex]
                            - cellView.layoutModel.bordertop / 2.0
                            - cellView.layoutModel.borderbottom / 2.0;
                        cellView.invalidateDisplay();

                    }

                },this);
            },this);
            return true;
        },

        updateDisplay : function(){
            xfalib.view.layout.TableLayout.prototype.updateDisplay.apply(this, arguments);
            this.$css(this.target.el, {"border-spacing":"0"});
            // LC-3911668 : Safari does not update the display when a DOM change is done in a table:
            if(xfalib.ut.XfaUtil.prototype.isSafari()) {
                this.target.$el.hide().css("height");this.target.$el.show();
            }
        }

    }, this);
})(_, $, xfalib);
(function (_, $, xfalib) {
    xfalib.view.layout.StaticLayout = xfalib.view.layout.LayoutBase.extend({

        measureSize : function () {
            var growableOffsetH = 0, growableAssignedH, newOffset;
            var initialGrowableBottom = -1;
            var growableView = this.target.growableView;
            var layoutModel = this.target.layoutModel;
            var growF = 0;
            if (!_.isEmpty(growableView)) {
                for (var i = 0; i < growableView.length; i++) {
                    if ((growableView[i].layoutModel.extenth - growableView[i].layoutModel.initialh) > 0) {
                        growF = i;
                    }
                }

                growableAssignedH = growableView[growF].layoutModel.initialh;
                newOffset = growableView[growF].layoutModel.extenth - growableAssignedH;
                initialGrowableBottom = growableView[growF].layoutModel.extenty + growableAssignedH;

                //bug#3475566, make an exception for first page and render it even if there is no content.
                if (!this.target._forceView() &&
                    growableView[growF].layoutModel.extenth <= (growableView[growF].layoutModel.margintop + growableView[growF].layoutModel.marginbottom)) {
                    //All the children of growable subform have either been removed or been hidden. So set it's height to zero as well.
                    growableOffsetH = -layoutModel.initialh;
                    layoutModel.measureddisplay = "hidden";
                }
                else {
                    if (newOffset > 0 || (!this._xfaViewRegistry().pagingConfig().shrinkPageDisabled &&
                        this.target._formDomRoot().host.numPages > 1)) {
                        //If view has overgrown or
                        //pageShrink is enabled and total number of pages are more that one then change the growableOffSet and move everything.
                        growableOffsetH = newOffset;
                        if (newOffset < 0 && this.target instanceof xfalib.view.PageView) {
                            this.target._formDomRoot().host.pagingManager.autoRenderPage();
                        }
                    }
                    layoutModel.measureddisplay = "block";
                }
            }
            var parentPadLeft = this._targetPaddingX();
            var parentPadTop = this._targetPaddingY();
            var oldExtentH = layoutModel.extenth;
            var containerH = layoutModel.initialh + growableOffsetH;
            _.each(this.target.childViews, function (childView, index) {
                childView.layoutModel.measuredx = parentPadLeft + childView.layoutModel.extentx;
                if (childView.layoutModel.extenty >= initialGrowableBottom) {
                    childView.layoutModel.measuredy = parentPadTop + childView.layoutModel.extenty + growableOffsetH;
                } else {
                    childView.layoutModel.measuredy = parentPadTop + childView.layoutModel.extenty;
                }
                if(layoutModel.measureddisplay !== "hidden") {
                    if (childView.model && childView.model.jsonModel && childView.model.jsonModel.presence !== "hidden" &&
                        childView.layoutModel.measuredy + childView.layoutModel.extenth > containerH) {
                        containerH = childView.layoutModel.measuredy + childView.layoutModel.extenth
                    }
                }
            }, this);

            layoutModel.extenth = containerH;
            if (oldExtentH != layoutModel.extenth) {
                return true;
            }
            else {
                return false;
            }
        },

        _getRootView : function () {
            return this._xfaViewRegistry().rootSubformView;
        },

        renderNextPage : function () {
            this._getRootView().renderDeferredPage();
        },

        updateDisplay : function () {
            xfalib.view.layout.LayoutBase.prototype.updateDisplay.apply(this, arguments);
            if (this.getOrElse(this.target, "layoutModel.measureddisplay", "") == "hidden") {
                this.$css(this.target.el, {"display" : "hidden"});
            }
            else {
                this.$css(this.target.el, {"display" : "block"});
            }
        }

    })
})(_, $, xfalib);




(function(_, $, xfalib){
    xfalib.view.layout.SubformSetLayout = xfalib.view.layout.LayoutBase.extend({
        measureSize : function(){
            //Subformset should always return true show that measureSize(0 of parent is called.
            return true;
        },

        invalidateSize : function(){
            if(this.target.parentView){
                this.target.parentView.invalidateSize();
            }
        }

        })
})(_, $, xfalib);




(function(_, $, xfalib){
    xfalib.view.layout.RootSubformLayout = xfalib.view.layout.LayoutBase.extend({
        measureSize : function(){
            return false;
        },

        updateDisplay : function(){
            return;
        }
    })
})(_, $, xfalib);




(function(_, $, xfalib){
    xfalib.view.layout.LayoutManager = xfalib.ut.Class.extend({
        LAYOUT_ERROR_MARGIN : 1,

        initialize : function(){
            xfalib.ut.Class.prototype.initialize.apply(this, arguments);
            this._invalidSizeQ = [];
            this._invalidDisplayQ = [];
            this._validatingSize = false;
            this._validatingDisplay = false;
            this._validationPending = false;
        },

        invalidateSize : function(view){
            if(this._validatingDisplay && view && view instanceof Object){
                xfalib.runtime.xfa.Logger.error("xfaView", "invalidateSize is called while validatingDisplay is running which is an issue. id" + view._id +
                    ", parent id:"+ (view.parentView && (view.parentView instanceof Object)) ? view.parentView._id : view.parentView);
            }

            if(!this._validatingSize && !this._validationPending){
                var that = this;
                this._validationPending = true;
                var timeout = window.setTimeout(function(){
                    that.triggerValidation();
                }, 1);
                xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(timeout);
            }

            var found = this.isPendingValidateSize(view);
            if(!found){
                this._invalidSizeQ.push(view);
            }
        },

        invalidateDisplay : function(view){
            var found = _.find(this._invalidDisplayQ, function(invalidView){
                if(invalidView == view){
                    return true;
                }
            });
            if(!found){
                this._invalidDisplayQ.push(view);
            }
        },

        triggerValidation : function(){
            if(this._validatingSize){
                xfalib.runtime.xfa.Logger.debug("xfaView", "validation is already running");
            }
            this._validationPending = false;
            this._validatingSize = true;
            while(this._invalidSizeQ.length > 0){
                var view = this._invalidSizeQ.shift();
                view._validateSize();
            }
            this._validatingSize = false;
            if (this._xfaViewRegistry().rootSubformView._formDomRoot()._modelInitialize === 'INITIALIZED') {
                this._xfaViewRegistry().rootSubformView._formDomRoot().form.execLayoutReady();
            }

            this._validatingDisplay = true;
            while(this._invalidDisplayQ.length >0){
                var view = this._invalidDisplayQ.shift();
                view._validateDisplay();
            }
            this._validatingDisplay = false;

             if (formBridge && xfalib.globals.highlight)   // highLight newly added fields
                $(formBridge).trigger("xfaLayoutComplete");
        },

        createLayout : function(view){
            var options = {target:view} ;
            if(view instanceof xfalib.view.RootSubformView)
                return new xfalib.view.layout.RootSubformLayout(options);
            else if(view instanceof xfalib.view.PageView )
                return new xfalib.view.layout.StaticLayout(options);
            else if(view instanceof xfalib.view.ContentAreaView)
                return new xfalib.view.layout.TopBottomLayout(options);
            else if(view instanceof xfalib.view.SubformSetView)
                return new xfalib.view.layout.SubformSetLayout(options);
            else if(view.el.nodeName == "TR")
                return new xfalib.view.layout.DataTableRowLayout(options);

            var layout = null;
            switch (view.layoutModel.layout)
            {
                case xfalib.view.LayoutConst.LAYOUT_LEFTRIGHTTOPBOTTOM:
                    layout = new xfalib.view.layout.LeftRightLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTTOPBOTTOM:
                    layout = new xfalib.view.layout.RightLeftLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_TOPBOTTOM:
                    layout = new xfalib.view.layout.TopBottomLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_TABLE:
                    layout = new xfalib.view.layout.TableLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_ROW:
                    layout = new xfalib.view.layout.RowLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW:
                    layout = new xfalib.view.layout.RightLeftRowLayout(options);
                    break;
                case xfalib.view.LayoutConst.LAYOUT_DATATABLE:
                    layout = new xfalib.view.layout.DataTableLayout(options);
                    break;
                default :
                    layout = new xfalib.view.layout.PositionLayout(options);
            }
            return layout;
        },

        isPendingValidateSize : function(view){
            return (this._invalidSizeQ.indexOf(view)  > -1);
        },

        _xfaViewRegistry : function() {
            return window.xfaViewRegistry;    //TODO: remove window dependency
        },
        /*
         * Checks whether any view has any kind of layout activity pending either in measure or update phase.
         */
        isLayoutCycleComplete : function(){
            return !(this._invalidSizeQ.length  > 0 || this._invalidDisplayQ.length > 0);
        }

    })
})(_, $, xfalib);

(function(_, $, xfalib){
    xfalib.view.XfaViewEvent = {
        PRESENCE_CHANGE : "presenceChange",
        EXTENT_CHANGE : "extentChange"
    }
})(_, $, xfalib);

(function(_, $, xfalib){
    xfalib.view.ObjectView = xfalib.ut.EventClass.extend({


        initialize : function(){
            xfalib.ut.EventClass.prototype.initialize.apply(this, arguments);
            this.id = this.options.id;
            this.$el = (this.options.el instanceof $) ? this.options.el : $(this.options.el);
            this.el = this.$el[0];
            this._layoutManager = this._xfaViewRegistry().layoutManager();
        },

        // jQuery delegate for element lookup, scoped to DOM elements within the
        // current view. This should be prefered to global lookups where possible.
        $: function(selector) {
            return this.$el.find(selector);
        },

        _formDomRoot : function() {
            return xfalib.script.Xfa.Instance; //TODO: Remove singleton dependency
        },

        _bind : function(context, func) {
            return function() {
                return func.apply(context, arguments);
            }
        },

        _xfaViewRegistry : function() {
            return window.xfaViewRegistry;    //TODO: remove window dependency
        },

        _mm2px : function(mmSize){
            return xfalib.view.util.Styles._mm2px(mmSize);
        },

        _convertToPx : function(size){
            return xfalib.view.util.Styles._convertToPx(size);
        },

        getOrElse : xfalib.ut.Class.prototype.getOrElse, //short cut but really needed to avoid duplicate code. May be better way next time.

        jqId: xfalib.ut.XfaUtil.prototype.jqId,

        matchJsonType: xfalib.ut.XfaUtil.prototype.matchJsonType,

        $data : xfalib.ut.XfaUtil.prototype.$data,

        $css : xfalib.ut.XfaUtil.prototype.$css

    });

})(_, $, xfalib);
(function(_, $, xfalib){
    var BaseView = xfalib.view.BaseView =  xfalib.view.ObjectView.extend({

        initialize : function() {
            xfalib.view.ObjectView.prototype.initialize.apply(this, arguments);
            this._id = this.el.id;
            this._initialized = false;
            this.parentView = this.options.parentView;
            this.tableCellIndex = this.options.tableCellIndex || 0;
            this.effectiveCellIndex = 0;
            this.model = null;
            this.layoutModel = null;
            this._invalidSizeFlag = true;
            this._invalidDisplayFlag = true;
            this._resizable = false;
            this.edgePresence = true;
            this.$data(this.el, "xfaView", this);
            if(this._id)
                this.model = this._formDomRoot()._xfaTemplateCache.getModel(this._id);
            if(this.model){
                this.createBorder();
                if(this.model.presence == "visible") {
                    this._initialized = true;
                } else {
                    var that = this;
                    var initHandler = {
                        handleEvent: function(evnt) {
                            if(evnt._property == "presence" && !that._initialized){
                                that._initLayout();
                                if(that._initialized){
                                    that.model.off(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, initHandler);
                                }
                            } else if(that._initialized){
                                //The only case when initHandler can be called even if it's initialized is in case of server side scripts which change presence on server.
                                //but does not call initHandler at that time. So we need to remove initHandler explicitly in next call.
                                that.model.off(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, initHandler);
                            }
                        }
                    };
                    this.model.on(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, initHandler);
                }
                this.model.on(xfalib.script.XfaModelEvent.DOM_CHANGED, this);


            }

        },

        createBorder : function(){
            var border = this.model.getElement("border",0,true),
                fill,
                color,
                edge;
            if(border){
                if((fill = border.getElement("fill",0,true)) && (color = fill.getElement("color",0,true))
                    && fill.presence!="hidden"
                    && fill.presence !="invisible"
                    ) {
                    color = color.value;
                    if(color == "")
                        color="255,255,255";     // if no color value is specified then fill default color
                    color = "rgb(" + color + ")";
                    $(this.el).css("background-color", color);
                }

                var allEdgeHidden = true,
                index = 0,
                edge;
                while(edge = border.getElement("edge",index,true)) {
                    if(edge.presence!="hidden" &&  edge.presence!="invisible") {
                        allEdgeHidden = false;
                        break;
                    }
                    index++;
                }
                if(border.presence == "visible"
                    && !allEdgeHidden) {
                    var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(border);
                    if(cssStyleObj){
                        this.$css(this.el, cssStyleObj);
                        return;
                    }

                } else {
                    // LC-3910380 : In case border presence or edge presence is invisible or hidden then marking border as none
                    if(border.presence=="hidden"
                        || border.presence=="invisible"
                        || allEdgeHidden){
                            $(this.el).css("border", "none");
                    }
                }
            }
            this.edgePresence = false;
        },

        //generic function to compute css style from the <font> & <para> element of the model
        _getTextStyle : function(referenceModel) {
            var cssStyleObj={};
            var asparaStylesObj = {};

            var fontElement = referenceModel.getElement('font',0,true);
            if(fontElement) {
                cssStyleObj['font-family'] = fontElement.getAttribute('typeface');
                cssStyleObj['font-size']   = this._convertToPx(fontElement.getAttribute('size'));
                cssStyleObj['font-style']  = fontElement.getAttribute('posture');
                cssStyleObj['font-weight'] = fontElement.getAttribute('weight');
                cssStyleObj['text-decoration'] = fontElement.getAttribute('underline') != 0 ? 'underline' : undefined;

                var fill = fontElement.getElement('fill',0,true);
                if(fill) {
                    var color = fill.getElement('color',0,true);
                    var colorValue = color.value;
                    if(colorValue) {
                        cssStyleObj['color'] = 'rgb('+colorValue+')';
                    }
                }
            }

            var para = referenceModel.getElement('para',0,true);
            if(para) {
                if(para.hAlign)  {
                    asparaStylesObj['right']= this._convertToPx(para.marginRight);
                    asparaStylesObj['left']= this._convertToPx(para.marginLeft);
                    asparaStylesObj['overflow']= "hidden";
                    switch(para.hAlign) {
                        case "right":
                            asparaStylesObj['text-align']= "right";
                            break;
                        case "left":
                        case "radix":  //Till now radix is not implemented, it is mapped to the default one i.e left
                            asparaStylesObj['text-align']= "left";
                            break;
                        case "center":
                            asparaStylesObj['text-align']= "center";
                            break;
                        case "justify":
                        case "justifyAll":
                            asparaStylesObj['text-align']= "justify";
                            break;
                    }
                }
                switch(para.vAlign) {
                   case "top":
                       asparaStylesObj['top']= this._convertToPx(para.spaceAbove);
                       break;
                   case "bottom":
                       asparaStylesObj['bottom']= this._convertToPx(para.spaceBelow);
                       break;
                }
                asparaStylesObj['text-indent'] = this._convertToPx(para.textIndent);
            }
            return {fontStyles : cssStyleObj, paraStyles :  asparaStylesObj};
        },

        _convertXFARichToHtml: function(text){
            var value;
            if(text != null)  {
             if(typeof text == 'string' && text[0] != '<') {
                 text = "<span>"+text+"</span>";   // $.replaceWith expects a HTML string
             }

             //--conversion to jQuery obj to handle font-size of span
             var spanText = $(text);
             spanText.find("*").each(function(index, span){
                  if(span.style) {
                      if(span.style.fontSize) {
                        value= xfalib.view.util.Styles._convertToPx(span.style.fontSize)+"px";
                        span.style['font-size'] = span.style.fontSize = value;
                   }
                }
             });

             text= "<span>"+spanText.html()+"</span>";
           }
           return text;
        },

        _initAccessibilityInfo: function() {
            //accessibility info

            if(this.layoutModel.colspan > 1) {
                this.$el.attr("colspan", this.layoutModel.colspan);
            }
            if(this.layoutModel.rowspan > 1) {
                this.$el.attr("rowspan", this.layoutModel.rowspan);
            }

            // TODO - move these table related stuff to table view
            //The below roles are not conflicting with the native accessibility support introduced in DataTables, but
            //not recommended until scripted data element is used (Refer to: http://www.w3.org/TR/aria-in-html/).
            //With the introduction of row-span and row header - the current info is not complete for ARIA-Roles
            //So if native HTML table is being used for render (DataTableLayout, do not add the ARIA-Roles below).
            // - No change required for table as layout for DataTable is  DATA_LAYOUT_TABLE
            // - Do not add accessibility for 'columnheader' or 'gridcell' if node is TH or TR (the check will also avoid the inefficient check)
            // - Do not add the accessibility for 'row' if node is TR
            var nodeName = this.el.nodeName;
            var partOfNativeTable = (nodeName == "TABLE"
                                    || nodeName == "TR"
                                    || nodeName == "TD"
                                    || nodeName == "TH");

            if(!partOfNativeTable) {
                if (this.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_TABLE) {
                    //put grid role
                    this.$el.attr("role", "grid");
                }
                else if (this._isTableHeaderCell()) {
                    this.$el.attr("role", "columnheader");
                }
                else if (this._isTableCell()) {
                    this.$el.attr("role", "gridcell");
                }
                else if (this.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW) {
                    this.$el.attr("role", "row");
                }
                else if (this.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) {
                    this.$el.attr("role", "row");
                }
            }
            //add role and title to this.$el
            var assist = this.model.getElement("assist", 0, true);
            if(assist && assist.role) {
                //translate XFA roles to HTML5 roles (WAria roles)
                if(assist.role == 'TR' && !partOfNativeTable)
                    this.$el.attr("role", "row");
                else if(assist.role == 'TH'){
                    //do nothing as header info is to be propagated to individual cells
                    //this.$el.attr("role", "row");
                }
                else if(assist.role == 'TF'){
                    //do nothing as header info is to be propagated to individual cells
                    //this.$el.attr("role", "row");
                }
                else if(!partOfNativeTable) {
                    // list role needs to be used for a div with list of items and listitem role for its children.
                    if(assist.role == 'UL') {
                        this.$el.attr("role", "list");
                    } else if(assist.role == "LI") {
                        this.$el.attr("role", "listitem");
                    } else {
                        this.$el.attr("role", assist.role);
                    }
                }
            }

            if (nodeName === "TABLE") {
                this.$el.attr("aria-label", this._getScreenReaderText());
            }

            //add lang parameter
            var lang = this._langFromLocale(this.model.jsonModel.locale);
            if(lang && lang.length > 0){
                this.$el.attr("lang", lang);
            }

            this._assignToolTip();
        },

        _assignToolTip : function () {
        },

        _getScreenReaderText: function(){
        },

        /**
         *
         * @param i
         * @param val
         * @return {String}
         * @private used by XfaDrawView and FieldView
         */
        _adjustTextCoordinate: function(i, val){
            //somehow jquery attr() function cannot read textLength attribute
            var sTextLen = this.getAttribute('textLength');
            if(sTextLen && val && val.length > 2) {
                //remove px
                var textLen = Number(sTextLen.substr(0, sTextLen.length-2));
                var x = Number(val.substr(0, val.length-2));
                //server adjust x for all rtl text content so we need to revert it back for webkit
                x += textLen;
                return x+"px";
            }
        },

        /**
         *
         * @private
         * internal function to extract lang from locale
         */
        _langFromLocale : function(locale) {
            var lang;
            if(locale && locale.length > 0) {
                //locale can be in the form of country_LANG -- en_US
                //Whereas lang attribute of html expects only country code
                var index = locale.indexOf('_');

                if(index != -1){
                    lang = locale.substr(0, index);
                }
                else {
                    lang = locale;
                }

                //leap of faith that lang would be ISO 631 complaint.
            }
            return lang;
        },

        setElement: function(element) {
          this.undelegateEvents();
          this._setElement(element);
          this.delegateEvents();
          return this;
        },

        _setElement: function(el) {
          this.$el = el instanceof $ ? el : $(el);
          this.el = this.$el[0];
        },


        delegateEvents: function(events) {
          var delegateEventSplitter = /^(\S+)\s*(.*)$/;
          events || (events = _.result(this, 'events'));
          if (!events) return this;
          this.undelegateEvents();
          for (var key in events) {
            var method = events[key];
            if (!_.isFunction(method)) method = this[method];
            if (!method) continue;
            var match = key.match(delegateEventSplitter);
            this.delegate(match[1], match[2], _.bind(method, this));
          }
          return this;
        },

        delegate: function(eventName, selector, listener) {
          this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);
          return this;
        },

        undelegateEvents: function() {
          if (this.$el) this.$el.off('.delegateEvents' + this.cid);
          return this;
        },

        _initLayout : function(){
            var presence = this.model ? this.model.presence : "visible";

            if(!this.layoutModel){
                //If layoutmodel has not been initialized, initialize that.
                this._initializeLayoutModel();
            }

            if(this._isPlaceHolderEl() && (presence == "visible" || presence == "invisible")){
                // Currently we are on a placeholder div el (because this element was hidden or inactive). It's time to find the actual element.
                var templateId = (this.model ? this.model._templateId() : this._id) || this._id;
                var actualEl = this._xfaViewRegistry().templateCache().get(templateId, true);
                if(actualEl){
                    // hides the actualEL as the layout is still disturbed, removes the hideElement class on updateDisplay
                    $(actualEl).addClass("hideElement");
                    this.$el.replaceWith(actualEl);
                    this.setElement(actualEl);
                    this.$data(this.el, "xfaView", this);
                    this._initializeLayoutModel(); //need to re-initialize layout model at this point.
                }
                else
                    xfalib.runtime.xfa.Logger.error("xfaView", "Html template could not be found. id:"+this._id+", som:"+this.getOrElse(this.model, "somExpression"));
            }

            if(presence == "visible"){
                var nodeName = "";
                if(this.model){
                    this.model.on(xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED, this);
                    this._initAccessibilityInfo();
                    nodeName = this.model.getAttribute("name");
                }
                // as part of html size reduction, server stopped sending node type and name of the component
                // add classes for the same
                var nodeType = (xfalib.ut.XfaUtil.prototype.$data(this.el, xfalib.view.LayoutConst.XFA_MODEL) ||{})[xfalib.view.LayoutConst.NODE_TYPE];
                if(nodeType)
                    this.$el.addClass(nodeType);
                if(nodeName != null && nodeName.length > 0) {
                    this.$el.addClass(nodeName);
                }
                var extent = this._computeExtent();
                this.$css(this.el, extent);
                this._initialized = true;
            } else{
                //If presence is set to visible then _handlePresenceChange is called as part of sync from subclasses
                // But otherwise we need to explicitlly call _handlePresenceChange here.
                this._handlePresenceChange({newText : presence});
            }
        },

        handleEvent: function(evnt) {
            switch(evnt.name) {
                case xfalib.script.XfaModelEvent.FORM_MODEL_CHANGED:
                    this.handleModelChanged(evnt);
                    break;
                case xfalib.script.XfaModelEvent.DOM_CHANGED:
                    this.handleDomChanged(evnt);
                    break;
                default:
                    /* log an error message */
            }
        },

        handleDomChanged : function(event){
            switch(event._property) {
                case "font.fill.color.value":
                    this._handleFontFillColorValue(event);
                    break;
                case "border.fill.color.value":
                case "textEdit.border.fill.color.value":
                case "numericEdit.border.fill.color.value":
                case "imageEdit.border.fill.color.value":
                case "signature.border.fill.color.value":
                case "dateTimeEdit.border.fill.color.value":
                case "passwordEdit.border.fill.color.value":
                case "choiceList.border.fill.color.value":
                    this._handleBorderFillColorValue(event);
                    break;
                case "border.edge.presence":
                    this._handleBorderEdgePresence(event);
                    break;
                case "border.edge.color.value":
                    this._handleBorderChange(event);
                    break;
                case "border.edge.thickness":
                    this._handleBorderChange(event);
                    break;
                case "border.fill.presence":
                    this._handleBorderFillPresence(event);
                    break;
                case "topInset":
                    this._handleTopInset(event);
                    break;
                case "bottomInset":
                    this._handleBottomInset(event);
                    break;
                case "leftInset":
                    this._handleLeftInset(event);
                    break;
                case "rightInset":
                    this._handleRightInset(event);
                    break;
            }
        },

        handleModelChanged : function(event) {
            if (event._property == "presence") {
                this._handlePresenceChange(event);
            } else if (event._property == "access") {
                this._handleAccessChange(event);
            }else if (event._property == "relevant")  {
                this._handleRelevantChange(event);
            }
        },

        _handleRelevantChange : function(event) {
//				xfa.Logger.debug("[_handlePresenceChange]presence:som"
//						+ event.newText + ":" + this.$el.data("som"));
            switch (event.newText) {
                case "+print":
                case "print" :
                    if(this.model.getAttribute("presence") == "visible")
                        this.el.style.visibility = "hidden" ;
                    break;
                case "-print":
                    if(this.model.getAttribute("presence") == "visible")
                        this.el.style.visibility = "visible";
                    break;
                default:
                    break;
            }
            this.parentView.invalidateSize();
        },

        _handlePresenceChange : function(event) {
//				xfa.Logger.debug("[_handlePresenceChange]presence:som"
//						+ event.newText + ":" + this.$el.data("som"));
            switch (event.newText) {
            case "visible":
                if(this.model.getAttribute("relevant") == "print" || this.model.getAttribute("relevant") == "+print")
                    this.el.style.visibility = "hidden" ;
                else this.el.style.visibility= "inherit";
                break;
            case "invisible":
            case "hidden":
            case "inactive":
                this.el.style.visibility = "hidden";
                break;
            default:
                this.el.style.visibility= "inherit";
                break;
            }
            /*
             FORMS-11363 : fix for height calculation of table cell
             Enable this toggle for old behaviour (if any regression comes)
             */
            if ((window.FD && window.FD.isToggleEnabled("FT_FORMS-11363")) && xfalib.runtime.xfa.form.mbInitialized) {
                this.parentView.invalidateSize();
            } else {
                this.parentView.invalidateSize();
            }

        },

        _handleRightInset : function(event) {
        },

        _handleBottomInset : function(event) {
            /*var bottomInset = parseFloat(event.prevText) ;
             if(bottomInset)  {
             var extent = this._computeExtent();
             extent["margin-bottom"] =  this._mm2px(25.4* bottomInset) ;
             this.layoutModel.marginbottom = extent["margin-bottom"];
             this._invalidDisplayFlag = true;
             this._validateDisplay();
             var a= this.measureSize();
             this.$css(this.el, extent);
             } */

        },

        _handleLeftInset : function(event) {
        },

        _handleTopInset : function(event) {
        },

        _handleFontFillColorValue : function(event) {

        },

        _handleBorderFillColorValue : function(event) {
            var borderFillColorValue = event.prevText;
            var visibility =  this.model.border.fill.presence ;

            if(borderFillColorValue && visibility != "invisible" && visibility != "hidden")  {
                if(borderFillColorValue.indexOf("rgb") == -1)
                    borderFillColorValue = "rgb(" + borderFillColorValue + ")";

                if (_.contains(["textEdit","numericEdit","imageEdit","signature","dateTimeEdit","choiceList",
                        "passwordEdit"], event._property.substring(0,event._property.indexOf('.')))) {
                    $(this.widget).css("background-color", borderFillColorValue);
                } else if( event._property === "border.fill.color.value") {
                    $(this.el).css("background-color", borderFillColorValue);
                }
            }
        },

        _handleBorderEdgePresence : function(event) {
            var visibility = event.prevText;
            var defaultBorder = "1px solid rgb(0, 0, 0)"
            if(visibility == "hidden" || visibility == "invisible") {
                $(this.el).css("border", "none");
            }
            else {
                var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(this.model.border);
                if(cssStyleObj)
                    this.$css(this.el, cssStyleObj);
                else $(this.el).css("border", defaultBorder);
            }


        },

        _handleBorderChange : function(event) {
            var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(this.model.border);
            if(cssStyleObj)
                this.$css(this.el, cssStyleObj);
        },

        _handleBorderFillPresence : function(event) {
            var borderFillPresence = event.prevText;
            var color = this.model.border.fill.color.value;
            if(borderFillPresence == "hidden" || borderFillPresence == "invisible"){
                $(this.el).css("background-color", "rgb(255,255,255)" )
            }
            else {
                if(color.indexOf("rgb") == -1)
                    color = "rgb(" + color + ")";
                $(this.el).css("background-color", color);
            }
        },

        _fillColor : function(color) {
            $(this.el).css("background-color", color)
        },

        _borderColor : function(color) {
            $(this.el).css("borderColor", color)
        },

        _handleAccessChange : function(event) {

        },

        /*
         * This method calls _initLayout in addition to calling original _syncFormToHtml.
         * This is specially useful when using server side scripts and calls deep sync.
         * If you are sure that object has been initialized call _syncFormToHtml else call this method.
         * Other objects(other than *this*) should always call this method insteadOf internal _syncFormToHtml method.
         */
        syncFormNodeToHtml: function(deepSync){
            if(!this._initialized && this._isPlaceHolderEl()){
                //If this is uninitialized placeHolderEl(in case presence is hidden initially and has not been changed since
                // then we want to attempt an _initLayout to check if presence needs to be handled.
                this._initLayout();
                if(!this._initialized && this._isPlaceHolderEl()){
                    //If this is still placeHolderEl then no point of running a sync
                    return;
                }
            }
            this._syncFormNodeToHtml(deepSync);
        },

        _syncFormNodeToHtml : function(deepSync) {
            // TODO : make sync logic better
            if (this.model) {
                this._handlePresenceChange({newText:this.model.presence})  ;
                //this._handleAccessChange({newText:this.model.mEffAccess})      ;
            }
            this.invalidateSize();
        },

        _initializeLayoutModel : function() {
            //In order to minimize the size of html generated, this layoutmodel is generated in a cryptic way
            //here is the mapping between the cryptic variables and explanatory variables.
            //in the interest of readability, preserving the good readable names

            var lm = this.getOrElse(this.$data(this.el, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL, {})
            var layout = {};
            if(this instanceof xfalib.view.ContainerView && !lm.hasOwnProperty(xfalib.view.LayoutConst.SUBFORM_LAYOUT)){
                layout.layout = "position";
            }
            else if(lm.hasOwnProperty(xfalib.view.LayoutConst.SUBFORM_LAYOUT)) {
                layout.layout = lm[xfalib.view.LayoutConst.SUBFORM_LAYOUT]
            }

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_X))
                layout.extentx = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_X]);
            else
                layout.extentx = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_Y))
                layout.extenty = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_Y]);
            else
                layout.extenty = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_MIN_W))
                layout.extentminw = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_MIN_W]);
            else
                layout.extentminw = -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_MIN_H))
                layout.extentminh = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_MIN_H]);
            else
                layout.extentminh = -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_MAX_W))
                layout.extentmaxw = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_MAX_W]);
            else
                layout.extentmaxw = -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_MAX_H))
                layout.extentmaxh = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_MAX_H]);
            else
                layout.extentmaxh = -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_W))
                layout.extentw = Math.max(this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_W]), layout.extentminw);
            else
                layout.extentw =  Math.max(0, layout.extentminw);

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_H))
                layout.extenth = Math.max(this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_H]), layout.extentminh);
            else
                layout.extenth =  Math.max(0, layout.extentminh);

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_ACTUAL_W))
                layout.extentactualw = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_ACTUAL_W]);
            else
                layout.extentactualw =  -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.EXTENT_ACTUAL_H))
                layout.extentactualh = this._mm2px(lm[xfalib.view.LayoutConst.EXTENT_ACTUAL_H]);
            else
                layout.extentactualh =  -1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.MARGIN_TOP))
                layout.margintop = this._mm2px(lm[xfalib.view.LayoutConst.MARGIN_TOP]);
            else
                layout.margintop = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.MARGIN_RIGHT))
                layout.marginright = this._mm2px(lm[xfalib.view.LayoutConst.MARGIN_RIGHT]);
            else
                layout.marginright = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.MARGIN_BOTTOM))
                layout.marginbottom = this._mm2px(lm[xfalib.view.LayoutConst.MARGIN_BOTTOM]);
            else
                layout.marginbottom = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.MARGIN_LEFT))
                layout.marginleft = this._mm2px(lm[xfalib.view.LayoutConst.MARGIN_LEFT]);
            else
                layout.marginleft = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.BORDER_TOP))
                layout.bordertop = this._mm2px(lm[xfalib.view.LayoutConst.BORDER_TOP]);
            else
                layout.bordertop = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.BORDER_RIGHT))
                layout.borderright = this._mm2px(lm[xfalib.view.LayoutConst.BORDER_RIGHT]);
            else
                layout.borderright = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.BORDER_BOTTOM))
                layout.borderbottom = this._mm2px(lm[xfalib.view.LayoutConst.BORDER_BOTTOM]);
            else
                layout.borderbottom = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.BORDER_LEFT))
                layout.borderleft = this._mm2px(lm[xfalib.view.LayoutConst.BORDER_LEFT]);
            else
                layout.borderleft = 0;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.COL_SPAN))
                layout.colspan = +lm[xfalib.view.LayoutConst.COL_SPAN];
            else
                layout.colspan = 1;

            if (lm.hasOwnProperty(xfalib.view.LayoutConst.ROW_SPAN))
                layout.rowspan = +lm[xfalib.view.LayoutConst.ROW_SPAN];
            else
                layout.rowspan = 1;

            if(lm.hasOwnProperty(xfalib.view.LayoutConst.COLUMN_WIDTHS)){
                var colWidths = lm[xfalib.view.LayoutConst.COLUMN_WIDTHS].split(" ");
                var calcWidths = _.map(colWidths,
                    function(colWidth){
                        return this._mm2px(colWidth);
                    },
                    this);
                layout.columnwidths = calcWidths;
            }

            if(this._isTableCell()){
                var columnWidth = -1;
                var tableLayoutModel = this.parentView.parentView.layoutModel;
                if(tableLayoutModel.columnwidths && tableLayoutModel.columnwidths.length >= this.tableCellIndex)
                    columnWidth = tableLayoutModel.columnwidths[this.tableCellIndex];
                if(columnWidth >= 0){
                    layout.extentw = columnWidth;
                    layout.extentactualw = columnWidth;
                    layout.extentminw = 0;
                    layout.extentmaxw = "none";
                }
            }
            layout.initialh = layout.extenth;
            layout.initialw = layout.extentw;

            if(lm.hasOwnProperty(xfalib.view.LayoutConst.CAP_PLACEMENT))
                layout.captionPlacement = lm[xfalib.view.LayoutConst.CAP_PLACEMENT];

            if(lm.hasOwnProperty(xfalib.view.LayoutConst.PAGE_NUMBER))
                layout.pageNumber = lm[xfalib.view.LayoutConst.PAGE_NUMBER];

            this.layoutModel = layout;
            this.resizable = this.layoutModel.extentactualw < 0 ||  this.layoutModel.extentactualh < 0;
        },

        _computeExtent : function() {
            var extent = {} ;
            extent["margin-left"] = this._marginLeft();
            extent["margin-right"] = this._marginRight();
            extent["margin-top"] = this._marginTop();
            extent["margin-bottom"] = this._marginBottom();
            extent["padding-left"] = this._padLeft();
            extent["padding-right"] = this._padRight();
            extent["padding-top"] = this._padTop();
            extent["padding-bottom"] = this._padBottom();
            extent["border-left-width"] = this._subPixelValue(this.layoutModel.borderleft);
            extent["border-right-width"] = this._subPixelValue(this.layoutModel.borderright);
            extent["border-top-width"] = this._subPixelValue(this.layoutModel.bordertop);
            extent["border-bottom-width"] = this._subPixelValue(this.layoutModel.borderbottom);
            extent["-webkit-box-sizing"] = "border-box";
            extent["-moz-box-sizing"] = "border-box";
            extent["box-sizing"] = "border-box";
            extent["position"] = "absolute";
            return extent;
        },

        _padLeft : function() {
            return this.layoutModel.marginleft
                    - this.layoutModel.borderleft / 2;
        },

        _padRight : function() {
            return this.layoutModel.marginright
                    - this.layoutModel.borderright / 2;
        },

        _padTop : function() {
            return this.layoutModel.margintop - this.layoutModel.bordertop / 2;
        },

        _padBottom : function() {
            return this.layoutModel.marginbottom
                    - this.layoutModel.borderbottom / 2;
        },

        _marginLeft : function() {
            return -this.layoutModel.borderleft / 2;
        },

        _marginRight : function() {
            return -this.layoutModel.borderright / 2;
        },

        _marginTop : function() {
            return -this.layoutModel.bordertop / 2;
        },

        _marginBottom : function() {
            return -this.layoutModel.borderbottom / 2;
        },

        _isTableCell : function(){ //Too long check??? Please shorten it.
            if(this.parentView && this.parentView.layoutModel &&
                (this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW || this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) &&
                this.parentView.parentView && this.parentView.parentView.layoutModel &&
                this.parentView.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_TABLE){
                  return true;
                }
            return false;
        },

        _isTableHeaderCell : function(){ //Too long check??? Please shorten it.
            if(this.parentView && this.parentView.layoutModel &&
                (this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW || this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) &&
                this.parentView.model.getElement("assist", 0, true) && this.parentView.model.assist.role == "TH"){
                return true;
            }
            return false;
        },


        //For a given cell identify if the cell is part of header row (THEAD)
        _isPartOfHeaderRow : function(){
            if(this.parentView && this.parentView.layoutModel &&
                (this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_ROW || this.parentView.layoutModel.layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTROW) &&
                this.parentView.el.parentNode.nodeName == "THEAD"){
                return true;
            }
            return false;
        },

        $computeWH : function(){
            //private method but still overridden in SubformSetView
            var extent = {};
            //If the field is not initialized(invisible or hidden), then there is no need to set w/h for el. This would automatically be done during initialization via sync
            extent["width"] = this.layoutModel.extentw + this.layoutModel.borderleft/2 + this.layoutModel.borderright/2;
            extent["height"] = this.layoutModel.extenth + this.layoutModel.bordertop/2 + this.layoutModel.borderbottom/2 ;
            return extent;
        },

        _isPlaceHolderEl : function(){
            return this.$data(this.el, "xfaHiddenPH");
        },

        //layout related functions
        invalidateSize : function(){
            this._invalidSizeFlag = true;
            this._layoutManager.invalidateSize(this);
            this.invalidateDisplay();
        },

        invalidateDisplay : function(){
            this._invalidDisplayFlag = true;
            this._layoutManager.invalidateDisplay(this);
        },

        _validateSize : function(recursive){
            if(this._invalidSizeFlag){
                if(this._initialized){
                    var sizeChanged = this.measureSize();
                    if(sizeChanged)
                       this.parentView.invalidateSize();
                }
                this._invalidSizeFlag = false;
            }
        },

        _validateDisplay : function(recursive){
            if(this._invalidDisplayFlag){
                if(this._initialized){
                    this.updateDisplay();
                    this.trigger("layoutComplete");
                }
                this._invalidDisplayFlag = false;
            }
        },

        measureSize : function(){
            var changed = false;
            if(!this.resizable){
                if(this.layoutModel.extenth != this.layoutModel.initialh){
                    this.layoutModel.extenth = this.layoutModel.initialh;
                    changed = true;
                }
                if(this.layoutModel.extentw != this.layoutModel.initialw){
                    this.layoutModel.extentw = this.layoutModel.initialw;
                    changed = true;
                }
            }
            return changed;
        },

        updateDisplay : function(){
            var extent = this.$computeWH();
            this.$css(this.el, extent);
            $(this.el).removeClass("hideElement");
        },

        _subPixelValue : function(value){
            if(value > 0.01)
                return Math.max(value, 1.0);
            else
                return value;
        },

        /*
         * Return the page number containing this view.
         * Note: page number starts with 1 instead of 0
         */
        _pageNumber : function(){
            //Page number is passed as argument to createView and is available in options
            return this.getOrElse(this, "options.pageNumber", -1);
        },

        /*
         * @function
         * Focuses the widget of the provided view.
         * @param {Object} view : view whose widget needs to be focussed.
         */
        _focusWidget : function (view) {
            var jqWidget = view.jqWidget;
            if (!jqWidget) {
                return;
            }
            if(xfalib.ut.XfaUtil.prototype._isIpad()) {
                var offset = jqWidget.$userControl.offset(),
                    top = offset.top,
                    left = offset.left;
                window.scrollTo(left,top) ;
            }
            jqWidget.focus();
        }

    });

    Object.defineProperty(BaseView.prototype, "resizable", {
        get : function(){
            return this._resizable;
        },

        set : function(sValue){
            this._resizable = sValue;
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.XfaDrawView = xfalib.view.BaseView.extend({
        $drawChild : null,

        initialize : function(){
            xfalib.view.BaseView.prototype.initialize.apply(this, arguments);
            this._initLayout();
            this._createAccessibilityInfo();
        },

        handleModelChanged : function(event) {
            switch(event._property) {
                case "rawValue" :
                                if(event.jsonModel.newText) {
                                    this._updateView(event.jsonModel.newText);
                                }
                                break;
                default:
                    xfalib.view.BaseView.prototype.handleModelChanged.apply(this,
                        arguments);
            }
        },

        handleDomChanged : function(event) {
             switch(event._property) {
                 case "value.text" :
                 case "value.exData" :
                                    if(event.jsonModel.newText) {
                                        this._updateView(event.jsonModel.newText);
                                    }
                                    break;
                 case "h" ://--we support computation only on line for now.
                                 if(this.getOrElse(this.model, "value.oneOfChild.className", "") === "line"){
                                     this._computeLineHeight();
                                 }
                                 break;
                 default:
                     xfalib.view.BaseView.prototype.handleDomChanged.apply(this,
                          arguments);
            }
        },

        _handleFontFillColorValue : function(event) {
            if(this.model && this.model.value) {
                var content = this.model.value.oneOfChild;
                var htmlText = content.jsonModel._value;
                if(content.getAttribute('contentType') == 'text/html') {
                    var $internalHTML = $('<span>'+htmlText+'</span>');
                    //change the top level element to span to wrap up all the <p>, because it will cause unnecessary paragraph break
                    //add 'display:inline' style
                    //no null check because jQuery is cool!
                    //ToDo: change all your paragraphs into <span> and add a <br> element between them
                    //this will work for few cases where there is one single paragraph in the text or plain text cases.
                    $internalHTML.find("p").eq(0).css('display','inline');
                    this._updateView($internalHTML[0]);
                }
                else
                    this._updateView(htmlText);
            }
            //now check the rawValue and update view based on that rawValue

        },

        _updateView : function(text) {
              if (this._initialized && this.model) {
                  var value = this.model.getElement('value',0, true);
                  if(value) {
                      var  child = value.oneOfChild;
                      if (["text","exData"].indexOf(child.className) !== -1) {
                          var cssObj = this._getTextStyle(this.model);
                          if (cssObj)
                              this.$css(this.el, cssObj.fontStyles);

                          text = xfalib.ut.XfaUtil.prototype.encodeScriptableTags(this._convertXFARichToHtml(text));
                          this.$el.children().replaceWith(text);
                          if (this.el.children[0] && cssObj) {
                              this.$css(this.el.children[0], cssObj.paraStyles);
                          }
                      }
                      else if (child.className === 'image' && text) {//if draw is of type image
                          this.$el.children()[0].setAttribute('src', 'data:;base64,' + text);
                      }

                      if(this.resizable){
                          this.invalidateSize();
                      }
                  }
            }
        },

        measureSize : function(){
            var resized = false,
                text = null,
                content = this.getOrElse(this, "model.value.oneOfChild", null);

            // check to resize draw only in case of floating field and is resizable
            if(this.resizable && this._isFloatingFieldPresent(content)){
                // if content is rich text, then use jquery html() to support rich text element else text()
                if(content && content.getAttribute('contentType') == 'text/html') {
                    text = this.$el.html();
                } else {
                    text = this.$el.text();
                }
                resized = xfalib.view.FieldView.prototype._updateWidgetModel.call(this, text);
            }
            return resized;
        },

        _getMeasurementOptions : function(){
           var measureOptions = xfalib.view.FieldView.prototype._getMeasurementOptions.apply(this, arguments),
               content = this.getOrElse(this, "model.value.oneOfChild", null);
           return $.extend({}, measureOptions, {
               contentType : content ? content.getAttribute('contentType') : "",
               isDraw : true,
               refEl : this.el
           });

        },
        /**
         * @function
         * Utility function to checks whether the draw is having floating field or not
         * @param {object} content : contains jsonValue , _origTmpltVal etc.
         * @returns {boolean} : true if draw contains floating field else false
         */
        _isFloatingFieldPresent : function (content) {
            if (content && content._origTmpltVal) {
                var $internalHTML = $('<span>' + content._origTmpltVal + '</span>');
                return $internalHTML.find('[xfa\\:embed]').length > 0;
            }
            return false;
        },

        _syncFormNodeToHtml : function(val) {
            //in order to save some bytes
            // we don't send xmlns attributes from server so set it here
            var children = this.$el.children(),
                value = null;
            if(children.length)
            {
                if (children[0].tagName === 'svg')
                {
                        // In case of kerning, we add letterSpacing in XDP. View generated contains spaced letters which are read separately
                        // by the screen readers, to avoid this we are checking if it contains letterSpacing, if yes then add aria-label
                        // on top level and hide nested elements from screen reader.
                        if(this.model && this.model.jsonModel && this.model.jsonModel.children){
                            for (var i = 0; i < this.model.jsonModel.children.length; i++) {
                                if(this.model.jsonModel.children[i]._class==="font"){
                                    if(this.model.jsonModel.children[i].letterSpacing){
                                        this.el.setAttribute('aria-label', this.model.rawValue);
                                        children[0].setAttribute('aria-hidden', 'true');
                                    }
                                    break;
                                }
                            }
                        }
                    children[0].setAttribute('role','presentation'); // CQ-4274732 : To prevent svg being read out as graphic
                    children[0].setAttribute('xmlns', 'http://www.w3.org/2000/svg');
                    children[0].setAttribute('xmlns:xlink', 'http://www.w3.org/1999/xlink');
                    children[0].setAttribute('focusable', 'false'); //LC-7105 LC-5444 svg tabIndex doesn't work so adding focusable as false
                    //Required so that draw do not spill out of their parent div.
                    var cssExtent = {};
                    cssExtent["width"] = "100%";
                    cssExtent["height"]= "100%";
                    this.$css(children[0], cssExtent);
                    if(this.getOrElse(this.model, "value.oneOfChild.className", "") === 'line'){
                       var pxHeight = xfalib.view.util.Styles._convertToPx(this.model.h);
                       var svgHeight = xfalib.view.util.Styles._convertToPx(children[0].getAttribute('height'));
                       if(svgHeight && pxHeight != svgHeight) {
                           this._computeLineHeight();
                       }
                    }
                }
            }

            if(this.model){
                value = this.model.getElement('value',0, true);
            }
            if(value) {
                var  child = value.oneOfChild;
                if (child._modelChanged === true) { //no need to check it here as updateview checks it anyway
                    var jsonVal = child.jsonValue || child.value; // call to child.value will use typedVal and strip off html tags : LC-5427
                    if (child.className === "image" && jsonVal == null) {
                        //for images, if the value is undefined or null return the href attribute
                        jsonVal = child.href;
                    }
                    this._updateView(jsonVal);
                } else { //for draw do it for the very first time as well
                    if (child.className === 'image') { //if draw is of type image
                        if (child.value) {
                            this.$el.children()[0].setAttribute('src',
                                'data:;base64,' + child.value);
                        } else {
                            this.$el.children()[0].setAttribute('src', child.href);
                        }
                    }
                }
            }

            xfalib.view.BaseView.prototype._syncFormNodeToHtml.apply(this, arguments);
        },

        _computeLineHeight : function() {   //lc-5463
           //-- computing line height
          var children = this.$el.children();
          var lineNode ={};
          if(children[0]) {
             lineNode = children[0].childNodes[0];
          }
          var pxHeight = xfalib.view.util.Styles._convertToPx(this.model.h);
          if(lineNode) {
             //--transforming the code from other units to pixel and changing its type to Numer for further computation
             var x1 = xfalib.view.util.Styles._convertToPx(lineNode.getAttribute('x1'));
             var x2 = xfalib.view.util.Styles._convertToPx(lineNode.getAttribute('x2'));
             var y1 = xfalib.view.util.Styles._convertToPx(lineNode.getAttribute('y1'));
             var y2 = xfalib.view.util.Styles._convertToPx(lineNode.getAttribute('y2'));

             var slope = (y2-y1)/(x2-x1);
             if(!isFinite(slope)) {
                y2 = y1 +  pxHeight;
                lineNode.setAttribute('y2',String(y2 +'px'));
                children[0].setAttribute('height',String(pxHeight +'px'));
                this.layoutModel.extenth = pxHeight ;
                var cssHeight = {};
                cssHeight['height'] = String(pxHeight +'px');
                this.$css(this.el, cssHeight);
             }
           /*if(slope == 0) {
                x2 = x1 +  pxHeight;
             }
             if(isFinite(slope) && slope != 0) {
                x2 = x1 +  pxHeight * Math.sin(Math.atan(slope)) ;
                y2 = y1 -  pxHeight * Math.cos(Math.atan(slope)) ;
             }*/
            // lineNode.setAttribute('x2',String(x2 +'px'));

          }
        },

        _initLayout : function(){
            xfalib.view.BaseView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                var drawType = this.getOrElse(this.$data(this.el, xfalib.view.LayoutConst.XFA_MODEL)[xfalib.view.LayoutConst.NODE_TYPE], "").toLowerCase();

                if(!$.browser.msie){
                    //All supported browser except IE are not able to gracefully handle 1px svg drawings.
                    // The reason for that, they start draw at grid lines and draw .5px on both sides of gridlines.
                    // Some browsers mix half pixel black with white to produce grey but others may not.
                    // To handle this consistently, we upgrade 1px drawings to 2px for non IE browsers.
                    if(drawType == "line"){
                        this.$('line[stroke-width="1px"]').attr("stroke-width", "2px");
                    }
                    else if(drawType == "rectangle"){
                        this.$('path[stroke-width="1px"]').attr("stroke-width", "2px");
                    }
                }

                if($.browser.webkit || $.browser.chrome || xfalib.ut.Utilities.checkMinMozillaVersion(28)){
                    //chrome handles the rtl text element in a different way.
                    //there is a similar function in FieldView
                    this.$('text[direction="rtl"]').attr('text-anchor', 'end');
                }


                this.$drawChild = $(this._findDrawElement());
                if(drawType == "line"){
                    //For very thin lines less than one pixel, to avoid missing lines, their containing div should be 1px minimum in size
                    if(this.layoutModel.extentw > 0.01 && this.layoutModel.extentw < 1.0)
                        this.layoutModel.extentw  = 1.0;
                    if(this.layoutModel.extenth > 0.01 && this.layoutModel.extenth < 1.0)
                        this.layoutModel.extenth = 1.0;
                }
                if(drawType == "rectangle"){
                    //To avoid missing edges of rectangle, their containing div should be *ceil*ed to next integer. Just heuristic/observation
                    this.layoutModel.extentw = Math.ceil(this.layoutModel.extentw);
                    this.layoutModel.extenth  = Math.ceil(this.layoutModel.extenth);
                }
                this._syncFormNodeToHtml(true);
            }
        },

        _createAccessibilityInfo: function() {
            var screenReaderText = this._getScreenReaderText();
            //add alt for img tags...
            if(screenReaderText && this.$drawChild && this.$drawChild.is("img")){
                this.$drawChild.attr("alt", screenReaderText)
            }
            else if(screenReaderText) {
                $(this).attr("aria-label", screenReaderText)
            }

            // check for heading roles
            var role = this.getOrElse(this.model.getElement("assist"), "role", "");
            if (/^H[1-6]$/.test(role)) {
                this.$el.attr("role", "heading").attr("aria-level", role[1]);
            }
        },

        _assignToolTip: function () {
            var toolTipText = xfalib.ut.XfaUtil.prototype._getToolTipText(this.model);
            if (toolTipText) {
                this.$el.attr("title", toolTipText);
            }
        },

        _getScreenReaderText : function(){
            if (this.model) {
                //find speak priority first ---
                var assist = this.model.getElement("assist", 0, true);
                var screenReaderText;

                var priority = "custom";
                var speak;
                var toolTip;

                if(assist ) {
                    //&& assist.speak && assist.speak.priority
                    speak = assist.getElement("speak", 0, true);
                    toolTip = assist.getElement("toolTip", 0, true);
                    if(speak) {
                        priority = speak.getAttribute('priority');
                    }
                }

                if(priority == "custom") {
                    if(speak) {
                        screenReaderText = speak.value;
                    }
                    else if(toolTip) {
                        screenReaderText = toolTip.value; //LC-6805: tooltip is shown as [Object Object] for text objects
                    }
                    else if(this.model.jsonModel.extras) {
                        screenReaderText = this.model.jsonModel.extras.caption;
                    }
                    else {
                        screenReaderText = this.model.jsonModel.name;
                    }
                }
                else if(priority == "toolTip") {
                    if(toolTip) {
                        screenReaderText = toolTip.value;
                    }
                    else if(this.model.jsonModel.extras) {
                        screenReaderText = this.model.jsonModel.extras.caption;
                    }
                    else {
                        screenReaderText = this.model.jsonModel.name;
                    }
                }
                else if(priority == "name") {
                    screenReaderText = this.model.jsonModel.name;
                }
                 return screenReaderText;

            }
        },

        _computeDrawChildExtent : function(){
            var extent = {};
            var drawType = this.getOrElse(this.$data(this.el, xfalib.view.LayoutConst.XFA_MODEL)[xfalib.view.LayoutConst.NODE_TYPE], "").toLowerCase();
            if(drawType == "text"){
                //This is to avoid truncation of svg text when SVG is larger than containing div.
                //In that case we allow SVG to be large upto extent of 120% of the assigned draw extents
                // Each browser handles svg differently. Below fix works for all supported browser and avoid 20% truncation which would handle most common cases.
                // Actual fix would require exact combined svg height/width calculation probably in XTG side.
                extent["width"] = "120%";
                extent["height"]= "120%";
            } else {
                //Required so that draw do not spill out of their parent div.
                extent["width"] = "100%";
                extent["height"]= "100%";
            }
            return extent;
        },

        _findDrawElement : function(){
            var drawEls = this.$el.children();
            if(drawEls.length >0)
                return drawEls.get(0);
        },

        updateDisplay : function(){
            xfalib.view.BaseView.prototype.updateDisplay.apply(this, arguments);
            if(this.$drawChild != null && !this.$drawChild.is("img")) {
                //only set extent if it is not img as img has its own extent
                var drawChildExtent = this._computeDrawChildExtent();
                //do this only if
                if(this.$drawChild.length)
                    this.$css(this.$drawChild.get(0), drawChildExtent);

            }
        }

    });
})(_, $, xfalib);(function(_, $, xfalib){
    var btwn = xfalib.ut.XfaUtil.prototype.btwn;

    xfalib.view.FieldView =  xfalib.view.BaseView.extend({
        //list of RTL languages
        _rtlLang:{he : "he", ar : "ar", fa: "fa"},

        _addOns:{
            "x-scribble-add-on" : xfalib.template.Constants.ScribbleImageField
        },
        initialize : function() {
            xfalib.view.BaseView.prototype.initialize.apply(this, arguments);
            this.captionLayoutModel = null;
            this.widgetLayoutModel = null;
            this.jqWidget = null;
            this.commitEvent = this.options.commitEvent;
            this.commitProperty = this.options.commitProperty;
            this.commitTarget = this.options.commitTarget;
            this.isError = false;

            this.caption = this._findCaption();
            this.widget = this._findWidget();
            if (this.widget) {
                this.createBorderForWidget();
                if(this.commitEvent != null) {
                    $(this.widget).on(this.commitEvent,
                        this._bind(this, this.handleCommit));
                }
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT,
                    this._bind(this, this.handleClickEvent));
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    this._bind(this, this.handleFocusOut));
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    this._bind(this, this.handleChangeEvent));
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_ENTER_EVENT,
                    this._bind(this, this.handleFocusEvent));
                $(this.widget).on("keypress",
                    this._bind(this, this.handleKeyPressEvent));
                $(this.widget).on(xfalib.ut.XfaUtil.prototype.XFA_PREOPEN_EVENT,
                    $.proxy(this.handlePreOpenEvent, this));
            }
            var that = this;
            if(this.caption) {
                this.$css(this.caption,{"cursor":"default"});
                //add presentation role to caption
                $(this.caption).attr("role", "presentation")
            }
            $(this.$el).on("mousedown", $.proxy(this._handleMouseDown,this))
                       .on("click", function(event) {
                            if(that.model.mEffectiveAccess != "open") {
                               return;
                            }
                            //label is clicked click the widget
                            if(!$(event.target).closest(".widget").length) {
                                that.jqWidget.click();
                            }
                        });
            this._initLayout();
        },

        createBorderForWidget : function(){
            if(this.model){
                var ui = this.model.getElement("ui", 0,true);
                var fill,color ;
                if(ui) {
                    var border = ui.oneOfChild.getElement("border", 0,true);
                    if(border && border.presence == "visible") {
                        if(this.caption  && parseInt(this.model.caption.getAttribute("reserve"))!=0  && this.model.parent.className !="exclGroup"){
                            var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(border);
                            if(cssStyleObj)
                                this.$css(this.widget, cssStyleObj);
                        } else if(!this.edgePresence  && this.model.parent.className !="exclGroup") {
                            var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(border);
                            if(cssStyleObj)
                                this.$css(this.widget, cssStyleObj);
                        }
                    }
                    if(border && (fill = border.getElement("fill",0,true)) && (color = fill.getElement("color",0,true))
                        && fill.presence!="hidden"
                        && fill.presence !="invisible"
                       ) {
                        var color = color.value;
                        if(color == "")
                            color="255,255,255";  // if no color value is specified then fill default color
                        color = "rgb(" + color + ")";
                        $(this.widget).css("background-color", color);
                    }
                }
            }
        },


        _handleMouseDown: function(event) {
            if( !$(event.target).closest(".widget").length && xfalib.view.FieldView.prototype.currentFocus == this ) {
                this.clickedOnCaption = true;
            }
        },

        _markAccess : function(access) {
            switch(access) {
                case "open" :
                    $(this.widget).removeClass("widgetreadonly");
                    break;
                case "nonInteractive" :
                case "protected" :
                    $(this.widget).addClass("widgetreadonly");
                    break;
                case "readOnly" :
                    $(this.widget).addClass("widgetreadonly");
                    break;
            }
        },

        _initLayout : function(){
            xfalib.view.BaseView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                this._initializeFieldChildLayoutAndExtent();
                this._syncFormNodeToHtml(true);
                this.markMandatory();
                this.$css(this.el, {"z-index": 2});
                if(this.caption){
                    //This is to avoid truncation of svg text when SVG is larger than containing div.
                    //In that case we allow SVG to be large upto extent of 120% of the assigned draw extents
                    // Each browser handles svg differently. Below fix works for all supported browser and avoid 20% truncation which would handle most common cases.
                    // Actual fix would require exact combined svg height/width calculation probably in XTG side.
                    var captionSVG = $(this.caption).children("svg").get(0);

                    // Due to extra 20%, Button-1 and Button-2 placed next to each other overlaps.
                    // So when clicking on Button-2, click on Button-1 gets triggered because of Button-1 overlapping area
                    // Removing extra 20% and hiding overflown SVG text for button field.

                    // Checking for submit and radio button
                    var hasParentButtonField = $(this.caption).parent().length && $(this.caption).parent().hasClass('buttonfield');
                    var hasSiblingButtonField = $(this.caption).siblings().length && $(this.caption).siblings().hasClass('buttonfieldwidget');
                    var hasParentRadioButtonField = $(this.caption).parent().length && $(this.caption).parent().hasClass('radiofield');
                    var hasSiblingRadioButtonField = $(this.caption).siblings().length && $(this.caption).siblings().hasClass('radiofieldwidget');
                    if(captionSVG){
                        $(captionSVG).attr('focusable', 'false'); //LC-7105 LC-5444 svg tabIndex doesn't work so adding focusable as false
                        //CQ-4274732 : To prevent svg being read out. Caption(svg) and input both are being read by screen reader, only focussable should be read.
                        $(captionSVG).attr('aria-hidden', 'true');
                        var captionChildExtent = {};
                        if((hasParentButtonField && hasSiblingButtonField) || (hasParentRadioButtonField && hasSiblingRadioButtonField)){
                            captionChildExtent["width"] = "100%";
                            captionChildExtent["height"]= "100%";
                            $(this.caption).css("overflow", "hidden");
                        }else{
                            captionChildExtent["width"] = "120%";
                            captionChildExtent["height"]= "120%";
                        }
                        this.$css(captionSVG, captionChildExtent);
                        if($.browser.webkit || $.browser.chrome || xfalib.ut.Utilities.checkMinMozillaVersion(28)){
                            //chrome handles the rtl text element in a different way.
                            //there is a similar function in XfaDrawView
                            $(captionSVG).children('text[direction="rtl"]').attr('x', this._adjustTextCoordinate);

                        }
                    }
                }
                //Invalidate the tab indexes for the page containing this field when this field is initialized.
                //This would just queue the tabbing computation for this particular page.
                this._xfaViewRegistry().invalidateTabIndex(this._pageNumber());
            }
        },

        handlePreOpenEvent: function(event) {
                this.model.execEvent("preOpen");
        },

        handleFocusEvent: function(event) {
            if(!this.clickedOnCaption) {
                this.model._xfa().setSubformFocus(this.model.parentSubform);
                this.model.execEvent("enter");
            }
            this.clickedOnCaption = false; // reset the state
            xfalib.view.FieldView.prototype._setFocusParam(this);
            if(formBridge) {
                if(formBridge.isAnalyticsEnabled) {   //Only computing when analytics enabled
                    var prevFocus=xfalib.view.FieldView.prototype.prevFocus,
                        currFocus=xfalib.view.FieldView.prototype.currentFocus;
                    if(prevFocus){  //if prevFocus is already null then no need to pass SOM Expression
                        prevFocus=prevFocus.model.somExpression;
                    }
                    if(currFocus){ //if currFocus is already null then no need to pass SOM Expression
                        currFocus=currFocus.model.somExpression;
                    }
                    xfalib.ut.XfaUtil.prototype._triggerOnBridge("elementFocusChanged", this.model, "focus", prevFocus, currFocus);
                }
                formBridge.clickedOnWindow = false;
            }
        },

        handleFocusOut : function(event) {
            if(!this.clickedOnCaption) {
                this.model.execEvent("exit");
            }
            if(formBridge && formBridge.clickedOnWindow === true) {
                xfalib.view.FieldView.prototype._setFocusParam(null);
                formBridge.clickedOnWindow = false;
            }
        },

        _setFocusParam : function(currFocus) {
            xfalib.view.FieldView.prototype.prevFocus = xfalib.ut.Class.prototype.getOrElse(xfalib.view.FieldView.prototype.currentFocus, null);
            //To minimize regression impact as "xfalib.view.FieldView.prototype.currentFocus" is used at all the places in the code
            xfalib.view.FieldView.prototype.currentFocus=currFocus;
        },

        _clearFocusInfo : function() {
            xfalib.view.FieldView.prototype.prevFocus = null;
            xfalib.view.FieldView.prototype.currentFocus=null;
        },

        handleKeyPressEvent: function(event) {
            var code = event.charCode || event.which || event.keyCode || 0;
            var character = String.fromCharCode(code);

            if(xfalib.ut.XfaUtil.prototype.isNonPrintableKey(event.key)) { // mozilla also generates a keypress, along with keydown
                return true;                                               // for all keys, so only handling printable keys in keypress
            }

            if(this.character != undefined) { // takes care of cases when xfa.event.change is set by user script
                if(this.character == null) {
                    this.jqWidget.option("value",this.jqWidget.option("curValue"));
                    this.jqWidget.option("displayValue",this.jqWidget.option("curValue"));
                }
                else if(this.character != character &&
                    !(event.key === "Enter" && this.character === "\n")) {
                    //String.fromCharCode returns \r for Enter key, but character is \n - ignore this mismatch
                    this.jqWidget.option("value",this.current);
                    this.jqWidget.option("displayValue",this.current);
                    event.preventDefault();
                }
                this.character = undefined;
            }
        },

        _syncFormNodeToHtml : function(deepSync) {
            var pluginOptions = this._createPluginOptions();
            if(!this.jqWidget)
                this.createWidgetPlugin(pluginOptions);
            else {
                _.each(pluginOptions, function(value, key){
                    this.jqWidget.option(key, value);
                }, this);
            }
            this._markAccess(this.model.mEffectiveAccess)
            if(this.model.__errorText)
                this._deferredMarkError();
            xfalib.view.BaseView.prototype._syncFormNodeToHtml.apply(this, arguments);
        },

        handleModelChanged : function(event) {
            if (event._property == this.commitTarget) {
                this._handleValueChange(event);
            }
            else{
                switch(event._property) {
                    case "focus":
                        this._focusWidget(this);
                        break;
                    case "ValidationState" :
                        this._markError(event);
                        break;
                    case "change":
                        this._handleEventChangeProperty(event);
                        break;
                    case "ClearError":
                        this._clearError(event);
                        break;
                    case "fillColor":
                        this._fillColor(event.newText);
                        break;
                    default:
                        xfalib.view.BaseView.prototype.handleModelChanged.apply(this,
                            arguments);
                }

            }
        },

        handleDomChanged :function(event){
            switch(event._property) {
                case "font.fill.color.value":
                    this._handleFontFillColorValue(event.prevText);
                    break;
                case "font.posture":
                    this._handleFontPosture(event.prevText);
                    break;
                case "value.maxChars":
                    this._handleMaxChars(event);
                    break;
                case "caption.font.fill.color.value":
                    this._handleCaptionFontFillColorValue(event);
                    break;
                case "nullTest":
                    this._handleNullTest(event, $(this.widget));
                    break;
                default:
                    xfalib.view.BaseView.prototype.handleDomChanged.apply(this, arguments);
            }
        },

        _handleNullTest: function (event, $target) {
            this._handleMandatory(event.newText, $target);
            this._handleDisabled(event);
        },

        _handleMandatory: function (change, $target) {
            if (_.contains(['disabled', 'warning'], change)) {
                $target.attr('data-mandatory', 'false')
                       .removeClass('widgetMandatoryBorder');
            } else if (change === 'error') {
                $target.attr('data-mandatory', 'true')
                       .toggleClass("widgetMandatoryBorder", xfalib.globals.highlight);
            }
        },

        _handleDisabled: function(event){
           var change = event.newText;
           if (change === 'disabled') {
              this._clearError(event);
           }
        },


        _handleCaptionFontFillColorValue :function(event) {
            var childSvg = this.caption.children[0];
            var fill = "rgb(" + event.prevText + ")" ;

            if(childSvg.tagName == "svg" && childSvg.childNodes) {
              _.each(childSvg.childNodes,function(node,index){
                if(node.tagName == 'text') {
                    this.$css(node,{'fill' : fill});
                }
              },this);
            }
        },

        _handleFontFillColorValue : function (value) {
            this.jqWidget.option("color", value);
        },

        _handleFontPosture : function (value) {
            this.jqWidget.option("font-style", value);
        },

        _handleMaxChars : function(event) {
            var maxchars = event.prevText;
            if(maxchars)
                this.jqWidget.option("maxChars",event.prevText);
        },

        handleCommit : function(event) {
            var resizeRqd = false;
            if(this.resizable && this.jqWidget.option("value") != this.model[this.commitTarget])
                resizeRqd = true;
            this.model[this.commitTarget] = this.jqWidget.option("value");
            if(resizeRqd)
                this.invalidateSize();
        },

        handleChangeEvent : function(changeEvent) {
            var current,
                event = changeEvent.originalEvent,
                maxChars = parseInt(this.jqWidget.option("maxChars") || this.jqWidget.option("combCells")) || 0, // to take care for both text & numeric fields
                val = this.jqWidget.option("curValue") || this.jqWidget.option("displayValue") || '',
                selectionStart = event.selectionStart,
                selectionEnd = event.selectionEnd,
                code = event.charCode || event.keyCode || event.which,
                character = event.character || '',
                change,
                fullText;

            if(event.originalType == "cut") {
                change = "";
                if(val) {
                    current = val.substr(0, selectionStart) + val.substr(selectionEnd);
                    fullText = current;
                }
            } else if(event.originalType == "keydown") {
                change = "";

                if(val) {
                    if (code == 8 || code == 46) {  // backSpace or Del
                        if (selectionStart !== selectionEnd) {
                            current = val.substr(0, selectionStart) + val.substr(selectionEnd);
                        } else {
                            if (code == 8) {  // backspace
                                current = val.substr(0, selectionStart - 1) + val.substr(selectionStart);
                            }
                            if (code == 46) {  // del
                                current = val.substr(0, selectionStart) + val.substr(selectionStart + 1);
                            }
                        }
                    }
                } else {
                    current = val;
                }
                fullText = current;
            }
            else { // keypress or paste
                change = character;
                if (maxChars > 0 ) {
                    if (val.length - (selectionEnd - selectionStart) >= maxChars) {
                        change = "";
                    } else {
                        change = character.substr(0, maxChars - val.length + selectionEnd - selectionStart);
                    }
                }

                if (val) {
                    current = val.substr(0, selectionStart) + change + val.substr(selectionEnd);
                    fullText = val.substr(0, selectionStart) + character + val.substr(selectionEnd);

                } else {
                    current = change;
                    fullText = character;
                }

                if( (maxChars !=0 && current.length  > maxChars) || !this.jqWidget.option("lengthLimitVisible") ) {
                    change = "";
                    current = val;
                }

                // LC-6290 : prevent paste from truncating any of the previous text
                if (event.originalType == "paste" &&
                    ((maxChars != 0 && fullText.length > maxChars) || !this.jqWidget.option("lengthLimitVisible"))) { // TODO : take care of multiline selection later
                    var self = this;
                    self.jqWidget.$userControl.one("input", function () {  // wait till the paste action occurs and then replace with correct value
                        self.jqWidget.$userControl.val(current)
                                                  .prop("selectionStart", selectionEnd) // LC-6290 : reset the cursor pos afterwards
                                                  .prop("selectionEnd", selectionEnd);
                    });
                }
            }

            var detail = {
                prevText:val,
                keycode:code,
                modifier:event.ctrlKey,
                keyDown: event.keyDown,
                shift:event.shiftKey,
                change:change,
                newText:current,
                fullText: fullText
            };
            if(!!change || current != val)
                this.model.execEvent("change", detail);
        },

        handleClickEvent : function(event) {
            var prevValue= this.jqWidget.option("value");
            var detail = {
                keycode:event.which,
                modifier:event.ctrlKey,
                shift:event.shiftKey
            };
            this.model.execEvent("click", detail);
        },

        _handleEventChangeProperty : function(event) {
            this.character = event.prevText;
            var prevValue= this.jqWidget.option("curValue") || this.jqWidget.option("displayValue") || "";
            var pos = this.jqWidget.options.pos ;
            this.current = prevValue.substr(0, pos) + this.character + prevValue.substr(pos);
            //var value = this.jqWidget.option("value") || "" ;
            //var displayValue = this.jqWidget.option("displayValue") || ""   ;

        },

        _handleValueChange : function(event) {
            //xfa.Logger.debug("[FieldView._handleValueChange]value:som"
            //        + event.newText + ":" + this.$el.data("som"));
            var resizeRequired =  (this.jqWidget.option("displayValue") != event.newText) && this.resizable ;
            this.jqWidget.option("value",event.prevText);
            this.jqWidget.option("displayValue",event.newText);
            if(resizeRequired){
                this.invalidateSize();
            }
        },

        _markError : function(evnt) {
            //this.$css(this.widget, "background-color","#D3D3D3");
            $(this.widget).addClass("widgetError");
            this.jqWidget.markError(evnt.newText, evnt.prevText);
            this._updateWidgetOption("isValid",false);
        },

        _deferredMarkError : function() {
            //this.$css(this.widget, "background-color","#D3D3D3");
            if(this.model.mandatory == "error")
                $(this.widget).addClass("widgetError");
            this.jqWidget.markError(this.model.__errorText, this.model.mandatory);
            this._updateWidgetOption("isValid",false);
        },

        _clearError : function(evnt) {
            //this.$css(this.widget, "background-color", "white");
            $(this.widget).removeClass("widgetError");
            this.jqWidget.clearError();
            this._updateWidgetOption("isValid",true);
        },

        // for all fields
        _updateWidgetOption: function(optionName, optionValue){
            this.jqWidget.option(optionName, optionValue);
        },

        _handleAccessChange : function(event) {
            //xfa.Logger.debug("[_handleAccessChange]access:som"
            //        + event.newText + ":" + this.$el.data("som"));
            this.jqWidget.option("access",event.newText);
            if(event.newText != event.prevText)
                this._markAccess(event.newText)
        },

        _findWidget : function() {
            if (this.$el.hasClass("widget"))
                return this.$el.get(0);
            else {
                var widgetList = this.$el.find(".widget");
                if (widgetList.length > 0){
                    return widgetList.get(0);
                }
            }
        },
        _findCaption : function() {
            var captionList = $(".caption", this.$el);
            if (captionList.length > 0){
                return captionList.get(0);
            }
        },

        _getParaStyles : function(){
            var paraStyles = {},para;
            para = this.model.getElement("para", 0, true);
            if(para){
                paraStyles = {
                    "text-align" : para.hAlign,
                    "vertical-align" : para.vAlign,
                    "text-indent" : this._convertToPx(para.textIndent),
                    "padding-left" : this._convertToPx(para.marginLeft),
                    "padding-right" : this._convertToPx(para.marginRight),
                    "padding-top" : this._convertToPx(para.spaceAbove),
                    "padding-bottom" : this._convertToPx(para.spaceBelow)
                };
            }
            return paraStyles;
        },

        _createPluginOptions : function() {
            if(this.model){
                var value = this.model[this.commitTarget] || null;
                var screenReaderText;
                screenReaderText = this._getScreenReaderText();
                var tabIndex = 0;
                if(this.model.jsonModel.extras && this.model.jsonModel.extras.tabIndex) {
                    tabIndex = this.model.jsonModel.extras.tabIndex;
                }

                var lang = this._langFromLocale(this.model._getLocale());
                var direction;

                if(lang && this._rtlLang[lang]){
                    direction = "rtl";
                }

                var paraStyles = this._getParaStyles();
                var widgetModel = this.widgetLayoutModel || this.layoutModel;
                return {
                    "name" : this.model.jsonModel.name+""+this._id,
                    "value" : value,
                    "displayValue": this.model.formattedValue,
                    "commitProperty" : this.commitProperty,
                    "access": this.model.mEffectiveAccess,
                    "platform": this.model._xfa().host.platform,
                    "screenReaderText": screenReaderText,
                    /*"tabIndex": tabIndex,*/
                    "paraStyles" : paraStyles,
                    "dir" : direction,
                    "hScrollDisabled" : !this.resizable && this.model.ui.oneOfChild.hScrollPolicy === "off",
                    "height" : widgetModel.extenth + widgetModel.bordertop/2 + widgetModel.borderbottom/2,
                    "commitEvent" : this.commitEvent
                };
            }

        },

        _getScreenReaderText: function () {
            var screenReaderText = "";
            if (this.model) {
                var assist = this.model.getElement("assist", 0, true);
                if (this.getOrElse(assist, "speak.disable", 0) != 1) { // loose compare string value

                    var priority = this.getOrElse(assist, "speak.priority", "speak"),
                        candidates = {
                            "speak": this.getOrElse(assist, "speak.value", ""),
                            "caption": this.getOrElse(this.model, "jsonModel.extras.caption", ""),
                            "toolTip": this.getOrElse(assist, "toolTip.value", ""),
                            "name": this.getOrElse(this.model, "jsonModel.name", "")
                        };

                    screenReaderText = candidates[priority] ||
                                       candidates["speak"] ||
                                       candidates["caption"] ||
                                       candidates["toolTip"] ||
                                       candidates["name"];
                    // CQ-85183 : going against xfa spec (pg 505) prioritise caption over tooltip
                }
            }
            return screenReaderText;
        },

        _assignToolTip: xfalib.view.XfaDrawView.prototype._assignToolTip,

		_instantiateWidget:function(widgetName,options){
		    if (widgetName && widgetName.length > 0) {
                    try{
                        $(this.widget)[widgetName](options);
                        return this.$data(this.widget, widgetName) ||
                               this.$data(this.widget, "xfaWidget-"+widgetName);
                    } catch(exception) {
                        xfalib.runtime.xfa.Logger.error("xfaView", "exception "+exception.message+" in creating user widget. widget:"+widgetName);
                    }
            }
		},
        _createScribbleWidgetOptions:function(options){
            var initParams = this.getOrElse(this.model.ui,"extras.children",null);
            var geoLocParam = _.find(initParams,function(obj){
	            return obj&&obj.name=="geoLocMandatoryOnIpad";    
            });

            var geoLocMandatoryOnIpad = (geoLocParam&&geoLocParam.value) || ( window.formBridge.userConfig
                                         && window.formBridge.userConfig['scribbleImageFieldConfig']
                                         && window.formBridge.userConfig['scribbleImageFieldConfig'].geoLocMandatoryOnIpad );
            return _.extend({
                              geoLocMandatoryOnIpad:geoLocMandatoryOnIpad
                            },options);
        },
        createWidgetPlugin : function(options) {
            var widgetConfig = this._xfaViewRegistry().widgetConfig();
            var widgetName;
			
            if(widgetConfig){
                    widgetName = _.filter(widgetConfig,
                    function(widgetName, selector){
                        if(this.$el.filter(selector).length >0)
                            return true;
                        else
                            return false;
                    },
                    this)[0];
            } 

            this.jqWidget = this._instantiateWidget(widgetName,options);
			
            if(!this.jqWidget){
                widgetName = this._getWidgetNameFromUiExtra();
                if (widgetName) {
                    this.jqWidget = this._instantiateWidget(widgetName, this._createScribbleWidgetOptions(options));
                }
            }
			
            if(!this.jqWidget){
					this._createDefaultWidgetPlugin(options);
			}
            xfalib.runtime.xfa.Logger.debug("xfaView", "creating user widget. widget:" + this.jqWidget._widgetName
            + " for " + this.model.somExpression);
        },

        /**
        * returns the name of the widget present in ui extras
        * @returns {string} widgetName
        */
        _getWidgetNameFromUiExtra : function () {
            var widgetName = null,
                uiExtrasName = this.getOrElse(this,"model.ui.extras.name",null);
            if(uiExtrasName && uiExtrasName.length >= 2 && this._addOns.hasOwnProperty(uiExtrasName)){
                widgetName = this._addOns[uiExtrasName];
            }
            return widgetName;
        },

        _createDefaultWidgetPlugin : function(options) {
            $(this.widget).defaultWidget(options);
            this.jqWidget = this.$data(this.widget, "xfaWidget-defaultWidget");
        },

        markMandatory : function(){
            if(this.model.mandatory== "error")
                if(this.widget)
                    $(this.widget).attr("data-mandatory", "true") ;

        },

        _initializeFieldChildLayoutAndExtent : function() {
            if (this.caption) {
                var cView = _.extend({}, xfalib.view.BaseView.prototype, {
                    el : this.caption,
                    $el : $(this.caption)
                });
                xfalib.view.BaseView.prototype._initializeLayoutModel.apply(cView);  //TODO: handle things when moving layout to formDom
                this.captionLayoutModel = cView.layoutModel;
            }
            if (this.widget && this.caption) {
                var wView = _.extend({}, xfalib.view.BaseView.prototype, {
                    el : this.widget,
                    $el : $(this.widget)
                });
                xfalib.view.BaseView.prototype._initializeLayoutModel.apply(wView);
                this.widgetLayoutModel = wView.layoutModel;
            }
        },

        _getMeasurementOptions : function(){
            var widgetModel = this.widgetLayoutModel || this.layoutModel;
            return ({
               refEl : this.jqWidget && this.jqWidget.$userControl ? this.jqWidget.$userControl[0] : null,
               width : (widgetModel.extentw - widgetModel.marginleft - widgetModel.marginright),
               height : (widgetModel.extenth - widgetModel.margintop - widgetModel.marginbottom),
               minWidth : (widgetModel.extentminw>-1)?(widgetModel.extentminw - widgetModel.marginleft - widgetModel.marginright):widgetModel.extentminw,
               minHeight :(widgetModel.extentminh>-1)?(widgetModel.extentminh - widgetModel.margintop - widgetModel.marginbottom):widgetModel.extentminh,
               maxWidth : (widgetModel.extentmaxw > -1)?(widgetModel.extentmaxw - widgetModel.marginleft - widgetModel.marginright):widgetModel.extentmaxw,
               maxHeight :(widgetModel.extentmaxh > -1)?(widgetModel.extentmaxh - widgetModel.margintop - widgetModel.marginbottom):widgetModel.extentmaxh
            });
        },

        measureSize : function(){
            var resized = false;
            if(this.resizable){
                var text = (this.model && this.model[this.commitTarget]!= null)? this.model[this.commitTarget] : "";
                resized = this._updateWidgetModel(text);
                if(resized && this.caption && this.widget && this.model.caption) {
                    switch(this.model.caption.getAttribute("placement")){
                        case "left":
                        case "right":
                            this.layoutModel.extentw  = this.layoutModel.marginleft + this._getCaptionReservedW() + this.widgetLayoutModel.extentw + this.layoutModel.marginright;
                            this.layoutModel.extenth = this.layoutModel.margintop + Math.max(this._getCaptionReservedH(), this.widgetLayoutModel.extenth) + this.layoutModel.marginbottom;
                            break;
                        case "top":
                        case "bottom":
                            this.layoutModel.extentw = this.layoutModel.marginleft + Math.max(this._getCaptionReservedW(), this.widgetLayoutModel.extentw) + this.layoutModel.marginright     ;
                            this.layoutModel.extenth  = this.layoutModel.margintop + this._getCaptionReservedH() + this.widgetLayoutModel.extenth + this.layoutModel.marginbottom;
                            break;
                    }
                }
            }
            return resized;
        },

        /**
         * @function
         * To update height and width of widget model
         * @param {String} text : text to be used to compute new height and width
         * return true if height or width updated else false
         */
        _updateWidgetModel : function (text) {
            var spaceAbove = 0,
                spaceBelow = 0,
                para = this.getOrElse(this, "model.para", null),
                resized = false,
                measureOptions = this._getMeasurementOptions(),
                measuredExtent = xfalib.view.util.TextMetrics.measureExtent(text, _.clone(measureOptions)),
                widgetModel = this.widgetLayoutModel || this.layoutModel;

            if(para) {
                spaceAbove = para.spaceAbove;
                spaceBelow = para.spaceBelow;
            }

            if(measureOptions.width != measuredExtent.width || measureOptions.height != measuredExtent.height) {
                resized = true;
                if(measureOptions.width != measuredExtent.width) {
                    widgetModel.extentw = widgetModel.marginleft + measuredExtent.width + widgetModel.marginright;
                }
                if(measureOptions.height != measuredExtent.height) {
                    widgetModel.extenth = widgetModel.margintop + measuredExtent.height + widgetModel.marginbottom + this._convertToPx(spaceAbove)
                        + this._convertToPx(spaceBelow);
                }
            }
            return resized
        },

        _getCaptionReservedW: function() {
            if(this.caption && this.model.caption){
                switch(this.model.caption.getAttribute("placement")) {
                    case "left" :
                    case "right" :
                        //in case left and right, "reserve" dictates the width of the caption
                        var reserve = this.model.caption.getAttribute("reserve");
                        return (reserve != "-1" ? this._convertToPx(reserve) : 0);
                        break;
                    case "top" :
                    case "bottom" :
                        return this.captionLayoutModel.extentw;
                        break;
                }
            }
            return 0;
        },

        _getCaptionReservedH: function() {
            if(this.caption && this.model.caption){
                switch(this.model.caption.getAttribute("placement")) {
                    case "left" :
                    case "right" :
                        return this.captionLayoutModel.extenth;
                        break;
                    case "top" :
                    case "bottom" :
                        //in case top and bottom, "reserve" dictates the height of the caption
                        var reserve = this.model.caption.getAttribute("reserve");
                        //CQ-102341 : Layout of older forms got disturbes which had no reserve value. So if no reserve is found the older value i.e this.captionLayoutModel.extenth is returned
                        return (this._isReservePresent(reserve) ? this._convertToPx(reserve) : this.captionLayoutModel.extenth);
                        break;
                }
            }
            return 0;
        },

        _isReservePresent: function(reserve) {
            try {
                return !(reserve == "-1" || parseFloat(reserve.replace(/[^-\d\.]/g, '')) == 0);
            } catch(exception) {
                xfalib.runtime.xfa.Logger.warn("xfa","issue with parseFloat of reserve , reserve value :" + reserve);
                return false;
            }
        },

        _calculateDisplay : function(capExtent,wExtent) {
             wExtent["width"] = this.widgetLayoutModel.extentw + this.widgetLayoutModel.borderleft/2 + this.widgetLayoutModel.borderright/2 ;
             wExtent["height"] = this.widgetLayoutModel.extenth + this.widgetLayoutModel.bordertop/2 + this.widgetLayoutModel.borderbottom/2 ;
             switch(this.model.caption.placement) {
               case "left" :
                  capExtent["left"] = this._padLeft();
                  capExtent["top"] = this._padTop();
                  wExtent["left"] = this._padLeft() + this._getCaptionReservedW();
                  wExtent["top"] = this._padTop();
                  break;
               case "right" :
                  capExtent["right"] = this._padRight();
                  capExtent["top"] = this._padTop();
                  wExtent["right"] = this._padRight() + Math.max(this._getCaptionReservedW(), capExtent["width"]);
                  wExtent["top"] = this._padTop();
                  break;
               case "top" :
                  capExtent["left"] = this._padLeft();
                  capExtent["top"] = this._padTop();
                  wExtent["left"] = this._padLeft();
                  wExtent["top"] = this._padTop() + this._getCaptionReservedH();
                  break;
               case "bottom" :
                  capExtent["left"] = this._padLeft();
                  capExtent["bottom"] = this._padBottom();
                  wExtent["left"] = this._padLeft();
                  wExtent["bottom"] = this._padBottom()  + this._getCaptionReservedH();
                  break;
           }
       },

        updateDisplay : function(){
            xfalib.view.BaseView.prototype.updateDisplay.apply(this, arguments);
            if(this.caption && this.widget){
                var parentPadLeft = this._padLeft();
                var parentPadTop = this._padTop();
                var capExtent = {};
                var wExtent = {};
                capExtent["width"] = this.captionLayoutModel.extentw + this.captionLayoutModel.borderleft/2 + this.captionLayoutModel.borderright/2 ;
                capExtent["height"] = this.captionLayoutModel.extenth + this.captionLayoutModel.bordertop/2 + this.captionLayoutModel.borderbottom/2 ;
                this._calculateDisplay(capExtent,wExtent);
                this.jqWidget.option("width",this.widgetLayoutModel.extentw - this.widgetLayoutModel.marginleft - this.widgetLayoutModel.marginright)
                             .option("height",this.widgetLayoutModel.extenth - this.widgetLayoutModel.marginbottom - this.widgetLayoutModel.margintop)
                this.$css(this.caption, capExtent);
                this.$css(this.widget, wExtent);
            }
            else {
                this.jqWidget.option("width",this.layoutModel.extentw - this.layoutModel.marginleft - this.layoutModel.marginright)
                             .option("height",this.layoutModel.extenth - this.layoutModel.marginbottom - this.layoutModel.margintop)
            }
        },

        updateTabIndex : function(newTabIndex){
            this.jqWidget.option("tabIndex", newTabIndex);
        },

        // CQ-102472 : Overriding BaseView _handleBorderChange, as in case of field with no caption, field border color gets assigned to widget border as no caption and field divs are present
        _handleBorderChange : function(event) {
            if (this.caption || this.model.border.edge.getAttribute("thickness", false)) {
                var cssStyleObj = xfalib.view.util.Styles.getStyleForBorder(this.model.border);
                if(cssStyleObj) {
                    this.$css(this.el, cssStyleObj);
                }
            }
        }

    });
})(_, $, xfalib);

(function(_, $, xfalib){
    xfalib.view.CheckButtonFieldView = xfalib.view.FieldView.extend({

        initialize : function(){
            xfalib.view.FieldView.prototype.initialize.apply(this, arguments);
        },

        _createDefaultWidgetPlugin :  function(options){
            if(this.model){
                options.size =  this.model.ui.oneOfChild.size;
                options.state = this.model.selectedIndex;
                options.states = this.model.ui.oneOfChild.allowNeutral == "1" ? 3:2;  // #bug=3650920, typeof allowNeutral is string
                $(this.widget).XfaCheckBox(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-XfaCheckBox");
            }
            else{
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this, [options]);
            }
        },

        /*
        //Note: The screenreader text for exclusion group should not behave differently, and should be aligned to PDF.
        //Reference: CQ-81875 (AEM Forms show radio button name included with tooltip)
        _getScreenReaderText: function() {
            var screenReaderText =  xfalib.view.FieldView.prototype._getScreenReaderText.apply(this),
                screenReaderTextParent;
            if(this.model.parent && this.model.parent._isExclusionGroup()) {
                screenReaderTextParent = this.parentView._getScreenReaderText();
                if(screenReaderTextParent) {
                    screenReaderTextParent = screenReaderTextParent + " " ;
                    if(screenReaderText) {
                        screenReaderText= screenReaderTextParent  +   screenReaderText;
                    } else {
                        screenReaderText = screenReaderTextParent;
                    }
                }
            }
                return  screenReaderText ;

        },
        */
        _handleMouseDown: function(event) {
            if(xfalib.view.FieldView.prototype.currentFocus == this) {
                this.clickedOnCaption = true;
            }
        },

        createBorderForWidget : function(){
        },

        handleChangeEvent : function(event) {
            if(this.model.parent.className == "exclGroup") {
                this.model.parent.execEvent("change");
            }
            this.model.execEvent("change");
        },

        handleClickEvent : function() {
            if(this.model.parent.className == "exclGroup") {
                this.model.parent.execEvent("click");
            }
            this.model.execEvent("click");
        },

        handleDomChanged :function(event){
            switch(event._property) {
                case "allowNeutral":
                    this._handleAllowNeutral(event);
                    break;
                default:
                    xfalib.view.FieldView.prototype.handleDomChanged.apply(this, arguments);
            }
        },

         _calculateDisplay : function(capExtent,wExtent) {
               var size = this._getWidgetReserved();  //-- we are changing the calculations from caption-centric to a widget centric
               this.widgetLayoutModel.extentw = this.widgetLayoutModel.extenth = size;
               var parentExtent = {};
               var paraField = this.model.getElement("para")
               if(paraField)
                 var vAlignWidget = paraField.getAttribute("vAlign");
               parentExtent["width"] = this.layoutModel.extentw + this.layoutModel.borderleft/2 + this.layoutModel.borderright/2 ;
               parentExtent["height"] = this.layoutModel.extenth + this.layoutModel.bordertop/2 + this.layoutModel.borderbottom/2 ;
               wExtent["width"] = this.widgetLayoutModel.extentw + this.widgetLayoutModel.borderleft/2 + this.widgetLayoutModel.borderright/2 ;
               wExtent["height"] = this.widgetLayoutModel.extenth + this.widgetLayoutModel.bordertop/2 + this.widgetLayoutModel.borderbottom/2 ;
               var topBottomPadding = (this.layoutModel.extenth-(this.widgetLayoutModel.extenth + this.captionLayoutModel.extenth))/2;

               switch(vAlignWidget) { // setting the vAlign of the widget equal to its parent. (i.e field)
                 case "bottom":
                        wExtent["bottom"]= this._padBottom();
                        break;
                  case "middle":
                        wExtent["top"] = (this.layoutModel.extenth-size)/2;
                        break;
                  case "top":
                  default:
                        wExtent["top"]= this._padTop();
               }

               switch(this.model.caption.placement) {
                    case "right" :
                        capExtent["left"] = this._padLeft() + size;
                        capExtent["top"] = this._padTop();
                        wExtent["left"] = this._padLeft()
                        break;
                    case "left" :
                        capExtent["right"] = this._padRight() + size;
                        capExtent["top"] = this._padTop();
                        wExtent["right"] = this._padRight();
                        break;
                    case "bottom" :
                        capExtent["left"] = this._padLeft();
                        capExtent["top"] = this._padTop()+ size + topBottomPadding;
                        wExtent["left"] = this._padLeft();
                        wExtent["bottom"]= undefined;
                        wExtent["top"] = this._padTop() + topBottomPadding ;
                        break;
                    case "top" :
                        capExtent["left"] = this._padLeft();
                        capExtent["bottom"] =this._padBottom()+ size + topBottomPadding;
                        wExtent["top"]= undefined;
                        wExtent["left"] = this._padLeft();
                        wExtent["bottom"] = this._padBottom()+ topBottomPadding;
                        break;
               }
               var lang = this._langFromLocale(this.model._getLocale());
               var direction = "ltr"
               if(lang && this._rtlLang[lang]){
                 direction = "rtl";
               }
               if(capExtent["width"]<(parentExtent["width"] - wExtent["width"])) {
                   switch(this.model.caption.placement) {
                       case "right" :
                           capExtent["left"] =  parentExtent["width"]-capExtent["width"] ;
                           break;
                       case "left" :
                           capExtent["right"] = undefined;
                           capExtent["left"] = this._padLeft();
                           wExtent["right"] = direction === "rtl" ? 0 : undefined
                           wExtent["left"] = direction === "rtl" ? undefined : this._padLeft()+capExtent["width"];
                           break;
                   }
               }
               if(capExtent["height"]<(parentExtent["height"] - wExtent["height"])) {
                   switch(this.model.caption.placement) {
                       case "bottom" :
                           capExtent["top"] = parentExtent["height"]-capExtent["height"];
                           break;
                       case "top" :
                           capExtent["bottom"] = parentExtent["height"]-capExtent["height"];
                           break;
                   }
               }

         },


        _getWidgetReserved: function() {
            if(this.widget ){
                 var size = this.model.ui.oneOfChild.getAttribute("size");
                 return (size != "-1" ? this._convertToPx(size) : 0);
            }
        },

        _handleAllowNeutral : function(event) {
            if(event.prevText) {
                if(event.prevText == "0" && this.model.getItemState(2)) {  // if button was in neutral,
                    this.model.setItemState(1, true);   // set it to off, while disabling allowNeutral
                }
                this.jqWidget.option("allowNeutral", event.prevText);
            }
        },

        _createPluginOptions : function(){
                var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(this, arguments);
            if(this.model) {
                //TODO: used _getDisplayItems. Internal API
                var vItems = _.map(
                    this.model._getDisplayItems() ? this.model._getDisplayItems().moChildNodes: [],
                    function(item, index){
                        return item.value;
                    }, this);
                vOptions.values = vItems;

                if(this.model.parent && this.model.parent._isExclusionGroup()) {
                    //push atleast one of these
                    vOptions.name = this.model.parent.name+""+this.parentView._id;
                }
            }
            return vOptions;
        }
    });

    Object.defineProperty(xfalib.view.CheckButtonFieldView.prototype, "resizable", {
        get : function(){
            return false;
        },

        set : function(sValue){
            //Do Nothing
        }
    });

})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.TextFieldView = xfalib.view.FieldView.extend({
        _createPluginOptions : function() {
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(this,
                    arguments);
            vOptions.multiLine = false;
            if (this.model) {
                var ui = this.model.getElement('ui', 0, true);
                var uiChild;

                if(ui) {
                    uiChild = ui.oneOfChild;
                    if(uiChild) {
                        vOptions.multiLine = uiChild.getAttribute("multiLine") == 0 ? false : true;
                    }
                }

                var value = this.model.getElement("value", 0, true);
                if(value) {
                    var valueChild = value.oneOfChild;
                    if(valueChild) {
                        var maxChars = valueChild.getAttribute("maxChars");
                        //note : maxChars/ numberOfCells as zero should be treated as undefined/no restriction
                        vOptions.maxChars = this.getOrElse(maxChars, undefined);
                    }
                    if(valueChild.className === "exData" && valueChild.jsonModel._value !== null && valueChild.jsonModel._value.indexOf("<body xmlns=") === -1){
                        valueChild._transformToXFACompliantModel();
                        vOptions.value = valueChild.jsonModel._value;
                    }
                }

                if(!vOptions.maxChars){
                    //note : numberOfCells as zero should be treated as undefined/no restriction
                    if(uiChild) {
                        var comb = uiChild.getElement("comb", 0, true);
                        if(comb) {
                            vOptions.maxChars = comb.getAttribute('numberOfCells');
                        }
                    }
                }
                if (!vOptions.fontSize) {
                    var font = this.model.getElement("font", 0, true);
                    if (font) {
                        vOptions.fontSize = this._convertToPx(font.size);
                        vOptions.fontFamily = font.typeface;
                    }
                }
            }
            return vOptions;
        },

        _createDefaultWidgetPlugin : function(options) {
            if(this._richTextSupport()){
                $(this.widget).richTextField(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-richTextField");
            }else{
                $(this.widget).textField(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-textField");
            }
        },

        _richTextSupport: function(){
           return(this.getOrElse(this.model, "value.oneOfChild.className", null) === "exData"? true:false);
        },

        createWidgetPlugin : function(options) {
            //cm-usecase: adding class to enable rich text widget registration against the class
            if(this._richTextSupport()) {
                this.$el.addClass('richtextsupport');
        }
            xfalib.view.FieldView.prototype.createWidgetPlugin.call(this,
                options);
        },


        _getMeasurementOptions : function() {
           var measureOptions = xfalib.view.FieldView.prototype._getMeasurementOptions.apply(this, arguments);
           // adding this option to check for fields requiring rich text support.
           measureOptions.contentType = this._richTextSupport() ? "text/html":"text/plain";
           measureOptions.skipXSSProtection = $(this.widget).data('skipXSSProtection');
           return measureOptions;
        },

        _getParaStyles : function(){
            var paraStyles = {},para;
            para = this.model.getElement("para", 0, true);
            if(para){
                paraStyles = xfalib.view.FieldView.prototype._getParaStyles.apply(this, arguments);
                paraStyles['line-height']= parseFloat(para.lineHeight)>0? this._convertToPx(para.lineHeight)+"px":"normal";
            }
            return paraStyles;
        }

    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.DateTimeFieldView = xfalib.view.FieldView.extend({

        _createDefaultWidgetPlugin : function(options) {
            if (this.model /*&& xfa.host.platform !== "iPad"*/) {
                $(this.widget).dateTimeEdit(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-dateTimeEdit");
            } else {
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this,[options]);
            }
        },

        _createPluginOptions : function(){
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(this, arguments);
            if(this.model) {
                var locale = this.model.locale;
                vOptions.days = this.model._xfa()._getLocaleSymbols(locale,"calendarSymbols.abbrdayNames");
                vOptions.months = this.model._xfa()._getLocaleSymbols(locale,"calendarSymbols.monthNames");
                vOptions.zero = this.model._xfa()._getLocaleSymbols(locale,"numberSymbols.zero");
                vOptions.clearText = xfalib.locale.Strings.clearText;
                vOptions.$clickable = this.$el;
                vOptions.useNativeWidget = false;
                var behaviorConfig = new xfalib.ut.Version(formBridge.userConfig["behaviorConfig"]);
                vOptions.showCalendarIcon = !behaviorConfig.isOn('mfDisableCalendarIcon');
                vOptions.calendarIconWidth = _.min([xfalib.template.Constants.calendarIconMaxWidth, Math.floor(vOptions.height)]) - 2;

                var editPattern = this.getOrElse(this.model, "ui.picture.value", null);
                if (editPattern) {
                    var parsedPattern = xfalib.ut.PictureUtils.parsePictureClause(editPattern);
                    if (_.isEmpty(parsedPattern) || _.isArray(parsedPattern) && parsedPattern.length > 1) {
                        editPattern = null; // for now fall back to default patterns in case of unsupported / multiple patterns
                        // TODO : make a array of the parsed objects and iter over them in abstract widget : parseEditValue
                    }
                }

                vOptions.editPattern = editPattern;
            }
            return vOptions;
        },

        handleChangeEvent: function(event) {
            //TODO: pass on the correct data
            var detail = {
                newText:null,
                keycode:null,
                modifier:null,
                keyDown:false,
                shift:false,
                change: null
            };
            this.model.execEvent("change", detail);
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.ImageFieldView = xfalib.view.FieldView.extend({

        _createDefaultWidgetPlugin : function(options) {
            $(this.widget).imageField(options);
            this.jqWidget = this.$data(this.widget, "xfaWidget-imageField");
        },

        _createPluginOptions : function() {
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(
                    this, arguments);
            var imageObj = this.getOrElse(this, "model.value.image", null);
            if (imageObj) {
                vOptions.aspect = imageObj.getAttribute("aspect");
            }
            return vOptions;
        },

        initialize : function() {
            xfalib.view.FieldView.prototype.initialize.apply(this, arguments);
        },

        handleChangeEvent : function(changeEvent) {
           this.model.execEvent("change");
           // NPR-15286 : to trigger event on formbridge whenever the value of scribble changes.
           if (this._getWidgetNameFromUiExtra() == xfalib.template.Constants.ScribbleImageField) {
               xfalib.ut.XfaUtil.prototype._triggerOnBridge(xfalib.template.Constants.scribbleChangeEvent, this.model, "change", this.model.somExpression);
           }
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.ButtonFieldView = xfalib.view.FieldView.extend({
        handleCommit : function(event){
            // xfa.Logger.debug("[ButtonFieldView.handleCommit]som" +
            // this.$el.data("som"));
            // do Nothing
        },

        handleClickEvent : function(event) {
            if(this.jqWidget.option("access") == "open") {
                xfalib.view.FieldView.prototype._setFocusParam(this);
                xfalib.view.FieldView.prototype.handleClickEvent.apply(this,arguments);
                xfalib.ut.XfaUtil.prototype._triggerOnBridge("elementButtonClicked", this.model, "click", this.model.somExpression);
            }
        },

        _handleKeyDown : function(event) {

        },

        handleDomChanged :function(event){
            switch(event._property) {
               case "caption.value.text":
                     this._handleCaptionValueChange(event.newText);
                     break;
               default:
                     xfalib.view.FieldView.prototype.handleDomChanged.apply(this,
                     arguments);
            }
        },

        _handleCaptionValueChange : function(text) {
             var  child = {};
             var caption = this.model.getElement('caption',0, true);
             var value = caption.getElement('value',0, true);

             if(value) {
                 child = value.oneOfChild;
                 if (["text","exData"].indexOf(child.className) !== -1) {
                    var cssObj = this._getTextStyle(caption);
                    if(cssObj) {
                        this.$css(this.caption, cssObj.fontStyles);
                    }
                    this.$css(this.caption, {'display':'table'}); // using this to utilise the css property vertical-align to account for vAlign
                    text=xfalib.ut.XfaUtil.prototype.encodeScriptableTags(this._convertXFARichToHtml(text));
                    $(this.caption.children[0]).replaceWith(text);
                    if(this.caption.children[0] && cssObj) {
                        this.$css(this.caption.children[0], cssObj.paraStyles);
                    }
                 }
             }
        },

        _getTextStyle : function(caption){
            var cssObj=xfalib.view.BaseView.prototype._getTextStyle.apply(this,[caption]);
            var para = caption.getElement('para',0,true);
            if(cssObj && para && para.vAlign) {
               cssObj.paraStyles['vertical-align']= para.vAlign;
               cssObj.paraStyles['display'] = 'table-cell';
            }
            return cssObj;
        },

        _createPluginOptions : function() {
            var pluginOptions = xfalib.view.FieldView.prototype._createPluginOptions.call(this);
            var paraStyles = null;
            if(this.model.getElement("caption", 0, true) && this.model.caption.getElement("para", 0, true)){
                var para = this.model.caption.para;
                paraStyles = {
                    "text-align" : para.hAlign,
                    "vertical-align" : para.vAlign,
                    "text-indent" : this._convertToPx(para.textIndent),
                    "padding-left" : this._convertToPx(para.marginLeft),
                    "padding-right" : this._convertToPx(para.marginRight),
                    "padding-top" : this._convertToPx(para.spaceAbove),
                    "padding-bottom" : this._convertToPx(para.spaceBelow)
                };
            }
            pluginOptions["paraStyles"] = paraStyles;
            pluginOptions["svgCaption"] = this.caption != null;
            return pluginOptions;
        },

        _createDefaultWidgetPlugin :  function(options){
            if(this.model){
                $(this.widget).xfaButton(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-xfaButton");
            }
            else{
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this, [options]);
            }
        }

    });
})(_, $, xfalib);(function(_, $, xfalib){
    xfalib.view.NumericFieldView = xfalib.view.FieldView.extend({
        _matchArray : { "integer":"^[+-]?\\d*$", "decimal":"^[+-]?\\dld(\\.\\dfd)?$", "float":"^[+-]?\\d*(\\.\\d*)?$" },
        _createPluginOptions : function() {
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(
                    this, arguments);
            if (this.model) {
                vOptions.dataType = this.model.value.oneOfChild.className ;
                vOptions.leadDigits = this.model.value.oneOfChild.leadDigits;
                vOptions.fracDigits = this.model.value.oneOfChild.fracDigits;
                vOptions.zero = this.model._xfa()._getLocaleSymbols(this.model.locale,"numberSymbols.zero");
                vOptions.decimal = this.model._xfa()._getLocaleSymbols(this.model.locale,"numberSymbols.decimal");
                //note : numberOfCells as zero should be treated as undefined/no restriction
                var uiChild = this.model.ui.oneOfChild;
                if(uiChild != null && uiChild.getElement("comb", 0, true) != null)
                    vOptions.combCells = this.model.ui.oneOfChild.comb.numberOfCells || undefined;
            }
            return vOptions;
        },

        _createDefaultWidgetPlugin : function(options) {
            if (this.model) {
                $(this.widget).numericInput(options);
                this.jqWidget = this.$data(this.widget, "xfaWidget-numericInput");
            } else {
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this,
                        [options]);
            }
        },

        handleCommit : function(event) {
            var _regex = null;
            var temp = this.jqWidget.option("value") + "";

            var ld = this.model.value.oneOfChild.leadDigits;
            var fd = this.model.value.oneOfChild.fracDigits;

            var matchStr = this._matchArray[this.model.value.oneOfChild.className];

            ld = (ld !== undefined && ~ld) ? "{0,"+ld+"}" : "*";
            fd = (fd !== undefined && ~fd) ? "{0,"+fd+"}" : "*";
            matchStr = matchStr.replace("ld", ld);
            matchStr = matchStr.replace("fd", fd);
            _regex = new RegExp(matchStr, "g");

            if (temp.match(_regex)) // if we need to keep this new	entered value
                xfalib.view.FieldView.prototype.handleCommit.apply(this, arguments);
            else
                 this.jqWidget.option("value",this.model[this.commitTarget]);
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.ChoiceListFieldView = xfalib.view.FieldView.extend({

        initialize: function () {
            xfalib.view.FieldView.prototype.initialize.apply(this, arguments);
            this._prevSelection = null;
        },

        _valueToArray: function(value) {
            var valueArray;
            if(value != null)
                valueArray = value.split("\n");
            else
                valueArray = [null];
            return valueArray;
        },

        _handleValueChange : function(event){
            //xfa.Logger.debug("[ChoiceListFieldView._handleValueChange]value:som" + event.newText + ":" + this.$el.data("som"));
            var prevText = this.jqWidget.option("displayValue");
            if (_.isArray(prevText)) {
                prevText = prevText.join("\n");
            }
            this._prevSelection = prevText;

            this.jqWidget.option("value",this._valueToArray(event.prevText));
            this.jqWidget.option("displayValue",this._valueToArray(event.newText));
        },

        handleCommit : function(event){
            //xfa.Logger.debug("[ChoiceListFieldView.handleCommit]som" + this.$el.data("som"));
            var val = this.jqWidget.option("value");
            if(_.isArray(val)){
                val = val.join("\n");
            }
            this.model[this.commitTarget] = val;
        },

        _createDefaultWidgetPlugin :  function(options){
            if(this.model)
            {
                if(this.model.ui.oneOfChild.open == 'always' || this.model.ui.oneOfChild.open == 'multiSelect'){
					//do role setting --
                    $(this).attr("role", "listbox"); //find a better place to do this
                    if($.browser.msie || $.browser.mozilla){
                        $(this.widget).nwkListBox(options);
                        this.jqWidget = this.$data(this.widget, "xfaWidget-nwkListBox");
                    }
                    else {
                        $(this.widget).listBox(options);
                        this.jqWidget = this.$data(this.widget, "xfaWidget-listBox");
                    }
                }
                else{
                    $(this.widget).dropDownList(options);
                    this.jqWidget = this.$data(this.widget, "xfaWidget-dropDownList");
                }
            }
            else{
                xfalib.view.FieldView.prototype._createDefaultWidgetPlugin.apply(this, [options]);
            }
        },

        _createPluginOptions : function(){
            var vOptions =  xfalib.view.FieldView.prototype._createPluginOptions.apply(this, arguments);
            if(vOptions.value!=null && !_.isArray(vOptions.value))
            {
                if(_.isString(vOptions.value))
                    vOptions.value = vOptions.value.split("\n");
                else
                    vOptions.value = [vOptions.value]; //convert new value to array
            }
            if(this.model)
            {
                var that = this;
                vOptions.editable =  (this.model.ui.oneOfChild.textEntry == '1');
                vOptions.multiSelect =  (this.model.ui.oneOfChild.open == 'multiSelect');
                var vItems = _.map(this.model._getDisplayItems() ? this.model._getDisplayItems().moChildNodes : [],
                    function(item, index){
                        var saveItem =  that.model.getSaveItem(index);
                        var displayItem = that.model.getDisplayItem(index);
                        return {
                            "save" : saveItem,
                            "display" : displayItem
                        };
                    }
                );
                vOptions.items = vItems;
            }
            return vOptions;
        },
        
        handleModelChanged : function(event) {
            if (event._property == "addItem") {
                this._handleAddItem(event);
            }
            if (event._property == "clearItems") {
                    this._handleClearItems(event);
            }
            if (event._property == "deleteItem") {
                this._handleDeleteItem(event);
        }
            else
                xfalib.view.FieldView.prototype.handleModelChanged.apply(this,
                        arguments);
        },

        handleChangeEvent : function(event) {
            var newValue =  this.jqWidget.option("displayValue");
            if(_.isArray(newValue)) {
                newValue = newValue.join("\n"); // return a string
            }
            var detail = {
                newText:newValue,
                prevText: this._prevSelection,
                keycode:event.which,
                modifier:event.ctrlKey,
                keyDown:event.which===40,
                shift:event.shiftKey,
                change: newValue
            };
            this.model.execEvent("change", detail);
        },
        
        _handleAddItem : function(event) {
        	var itemValues = {
        			sDisplayVal:event.newText,
        			sSaveVal:event.prevText
                };
        	this.jqWidget.addItem(itemValues);
            },
        
        _handleClearItems : function(event) {
        	this.jqWidget.clearItems();
            },
                   
        _handleDeleteItem : function(event) {
        	this.jqWidget.deleteItem(event.newText);
        }

    });
})(_, $, xfalib);
(function(_, $, xfalib){

    xfalib.view.ContainerView = xfalib.view.BaseView.extend({
        initialize : function() {
            xfalib.view.BaseView.prototype.initialize.apply(this, arguments);
            this.layoutTemplate = {};
            this.childViews = [];
            this.layout = null;
            this._initLayout();
        },

        _initLayout : function(){
            xfalib.view.BaseView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                this._processLayoutTemplate();
                this.layout = this._layoutManager.createLayout(this);
                if (this.model) {
                    this.model.on(xfalib.script.XfaModelEvent.CHILD_ADDED,this);
                    this.model.on(xfalib.script.XfaModelEvent.CHILD_REMOVED,this);
                    this.model.on(xfalib.script.XfaModelEvent.CHILD_MOVED,this);
                }
                this._syncFormNodeToHtml(true);
            }
        },

        _processLayoutTemplate : function(){
            var xfaTemplateCache = this._formDomRoot()._xfaTemplateCache;
            var htmlTemplateCache = this._xfaViewRegistry().templateCache();
            var that = this;
            var initialFormNode = xfaTemplateCache.getInitialFormDomRef(this._id);
            if(!initialFormNode){
                this.layoutTemplate.hasTemplate = false;
                return;
            } else
                this.layoutTemplate.hasTemplate = true;

            this.$elchildren().each(function() {
                var iChildNode = xfaTemplateCache.getInitialFormDomRef(this.id);
                if(!iChildNode)
                    return;

                var partBegin = true,
                    partSplit = false,
                    partEnd = true;
                var occurrences = that.getOrElse(that.$data(this, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL+"."+xfalib.view.LayoutConst.OCCURRENCES, 1); //occurrences
                var currentOccurence = that.getOrElse(that.$data(this, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.LAYOUT_MODEL+"."+xfalib.view.LayoutConst.OCCUR_INDEX, 0); //occurIndex
                if(currentOccurence != 0){
                    //The part has been split and currentOccurance is not zero. That means this element does not start in the parent layout.
                    partBegin = false; // not really used anywhere
                }
                if((occurrences - currentOccurence) > 1){
                    //This means that this element layout has been split into multiple parts and this part is not last part.
                    partSplit = true;
                    partEnd = false;
                }
                var childTemplateId = xfaTemplateCache.getTemplateRef(iChildNode.extras.htmlId).extras.htmlId;
                that.$data(this, "templateId", childTemplateId); // Set the templateId as actual id may change.
                if(xfalib.ut.XfaUtil.prototype.isTableHF(iChildNode)){
                    //A super hack for #3468407 till we support leader/trailer. For Table Header/Footer we may not have IM before it. So handle exclusively till we fix it
                    that.layoutTemplate[iChildNode.extras.htmlId] = {hasFirstPartBegin : partBegin, hasLastPartOverflow : partSplit};
                }
                else if(iChildNode && that.getOrElse(that.$data(this, xfalib.view.LayoutConst.XFA_MODEL), xfalib.view.LayoutConst.NODE_TYPE ,"").toLowerCase() == "subform"){
                    var instanceIndex = -1;
                    var sfIM = null;
                    var found = _.find(initialFormNode.children, function(initChild){
                        if(that.matchJsonType(initChild, "instanceManager")){
                            sfIM = initChild;
                            instanceIndex = -1;
                            return false;
                        }
                        else {
                            instanceIndex = instanceIndex + 1;
                            if(initChild == iChildNode)
                                return true;
                            else
                                return false;
                        }
                    });
                    if(found){
                        // if repeatable put in cache, along with current occurIndex for later stitching
                        if(iChildNode.extras.htmlId == childTemplateId && sfIM && (parseInt(that.getOrElse(sfIM.max, xfalib.script.Occur.prototype._defaults.max)) < 0 ||
                            parseInt(that.getOrElse(sfIM.min, xfalib.script.Occur.prototype._defaults.min )) < parseInt(that.getOrElse(sfIM.max, xfalib.script.Occur.prototype._defaults.max )))){
                            htmlTemplateCache.put(this.cloneNode(true));
                        }
                        var isLastChild = true;
                        var childIndex = initialFormNode.children.indexOf(iChildNode);
                        if(initialFormNode.children.length > childIndex +1 &&
                            that.matchJsonType(initialFormNode.children[childIndex + 1], "subform")){
                            isLastChild = false;
                        }
                        instanceIndex = instanceIndex + currentOccurence/1000;  // hack, assume at most 1000 instances of a rpt. SF.
                                                                               // the decimal part is used to judge the overflowed part which has split over multiple pages
                        that.layoutTemplate[childTemplateId] = !_.isEmpty(that.layoutTemplate[childTemplateId]) ? that.layoutTemplate[childTemplateId] : {
                            id: childTemplateId,
                            start : instanceIndex,
                            end : instanceIndex,
                            hasFirstPartBegin : partBegin,
                            hasLastPartOverflow : partSplit
                        };
                        that.layoutTemplate[childTemplateId].end = isLastChild && partEnd ? -1 : instanceIndex;
                        that.layoutTemplate[childTemplateId].hasLastPartOverflow = partSplit;
                    }
                } else {
                    that.layoutTemplate[childTemplateId] = {hasFirstPartBegin : partBegin, hasLastPartOverflow : partSplit};
                }
            }) ;
        },

        _syncFormNodeToHtml: function(deepSync){
            var that = this;
            var htmlTemplateCache = this._xfaViewRegistry().templateCache();
            var oldIdToChildViews = {};
            var newIdToChildViews = {};
            var cellIndex = 0;
            var lastSibling = null;

            //cache the old child views against their IDs
            _.each(this.childViews, function(childView){
                oldIdToChildViews[childView.el.id] = childView;
            }, this);

            _.each(this.getOrElse(this, "model.children", []),
                function(childModel){
                    if(!this._validateLayoutTemplate(childModel))
                        return;
                    var cTemplateId = childModel._templateId();
                    var id = childModel.htmlId;
                    var childEl = this.$elchildren(that.jqId(id))[0];
                    if(!childEl && (!newIdToChildViews.hasOwnProperty(cTemplateId) && !oldIdToChildViews.hasOwnProperty(cTemplateId))){
                        childEl = this.$elchildren(that.jqId(cTemplateId))[0];
                    }
                    if(!childEl){
                        if(!this._isHidden(childModel)){
                            var htmlTmplt = htmlTemplateCache.get(cTemplateId, true);
                            if(!htmlTmplt){
                                xfalib.runtime.xfa.Logger.error("xfaView", "Html template could not be found. cTemplateId:"+cTemplateId+", som:"+childModel.somExpression);
                                return;
                            }
                            else{
                                childEl = htmlTmplt;
                            }
                        }
                        else {
                            var xfaHiddenPH = $("<div></div>");
                            if(childModel instanceof xfalib.script.Draw){
                                xfaHiddenPH.addClass("draw");
                            }
                            else if(childModel instanceof xfalib.script.Field){
                                xfaHiddenPH.addClass("field");
                            }
                            childEl = xfaHiddenPH.get(0);
                            //TODO: below way of finding nodetype is not always true and may break hidden objects. We will need robust way to get node type that can be used by XfaViewRegistry.nodeTyperegistry.
                            //But for current implementation it would work as we care only about container node types.
                            var elNodeType = childModel.className.toLowerCase();
                            this.$data(childEl, "xfaHiddenPH", true);
                            var xfaModelObj = {};
                            xfaModelObj[xfalib.view.LayoutConst.NODE_TYPE] = elNodeType;
                            this.$data(childEl, xfalib.view.LayoutConst.XFA_MODEL, xfaModelObj);
                        }
                    }
                    childEl.id = childModel.htmlId;

                    this.$data(childEl,"templateId", cTemplateId); //Required for nested template ELs
                    var view = null;
                    if(oldIdToChildViews.hasOwnProperty(childEl.id)) {
                        view = oldIdToChildViews[childEl.id];
                        if(lastSibling && lastSibling.model instanceof xfalib.script.Subform && lastSibling.model.instanceManager._isRepeatable())
                            lastSibling.$el.after(view.$el); //The repeatable subform might have moved using moveInstance. So position it after it's sibling.
                        if(deepSync)
                            view.syncFormNodeToHtml(deepSync); //Sync existing views only if deepSync is requested
                    } else {
                        view = this._createChild(childEl, cellIndex, lastSibling);
                    }
                    cellIndex = cellIndex + (view.layoutModel.colspan || 1); //Add the colspan or one
                    newIdToChildViews[childModel.htmlId] = view;
                    lastSibling = view;
                }, this
            );

            this.childViews = [];
            if (!this.$el.is(":empty")) {
                this.$elchildren().each(function() {
                    if(newIdToChildViews.hasOwnProperty(this.id))
                        that.childViews.push(newIdToChildViews[this.id]);
                    else {
                         xfalib.runtime.xfa.Logger.log("xfaView",5,"removing element as no corresponding form dom node found. id:" + this.id + ", parent id:"+ that._id);
                        $(this).remove();
                    }
                }) ;
            }
            xfalib.view.BaseView.prototype._syncFormNodeToHtml.apply(this, arguments);   //sync other props before layout
        },

        _createChild : function(childEl, cellIndex, previousSibling){
            var view = this._xfaViewRegistry().createView(childEl, {
                    parentView: this,
                    tableCellIndex : cellIndex,
                    pageNumber: this._pageNumber()
                });
//            if(this.resizable || view._isPlaceHolderEl()){
//                //We also need to call layoutContainer for the cases where the object is initially hidden even if parent is not resizable
//                // since we do not have el for hidden object as yet,. TODO: optimize it.
//                view.on(xfalib.view.XfaViewEvent.EXTENT_CHANGE +" "+ window.xfalib.view.XfaViewEvent.PRESENCE_CHANGE,
//                    this._layoutContainer, this);
//            }
            if(this.$el.find(view.$el).length < 1){
                if(previousSibling)
                    previousSibling.$el.after(view.$el);        //Push the element after the sibling
                else
                    this.$el.prepend(view.$el);      //push the element at the begining of parent if no sibling is found,\.
            }
            return view;
        },

        _validateLayoutTemplate : function(childModel){
            var cTemplateId = childModel._templateId();
            if(xfalib.ut.XfaUtil.prototype.isTableHF(childModel)){
                //A super hack for #3468407 till we support leader/trailer. For table Header/Footer, templateId would be this same htmlId.
                cTemplateId = childModel.htmlId;
            }
            if(!this._isPaintable(childModel))
                return false;
            if(this.layoutTemplate.hasTemplate){
                var xfaTemplateCache = this._formDomRoot()._xfaTemplateCache;
                var iChildJson = xfaTemplateCache.getInitialFormDomRef(childModel.htmlId); //find the t0 version of this child
                if(!this.layoutTemplate.hasOwnProperty(cTemplateId) && !this._isHidden(iChildJson))
                    return false; // Here because the page has been split and this childModel is rendered in different page
                else if(!this.layoutTemplate.hasOwnProperty(cTemplateId) && this._isHidden(iChildJson)){
                    //if this child may not present in layout template if it was hidden at t0 becase for hidden containers layout is not generated.
                    //So we need to put extra effort to check if this hidden object fits layout template of this view.
                    var valid = this._validateHiddenChildLayout(childModel);
                    if(valid){
                        //if found validated, cache it for future. Also hidden part are automatically stitched into one part, so hasLastPartOverflow would false
                        this.layoutTemplate[cTemplateId] = {hasFirstPartBegin: true, hasLastPartOverflow : false};
                    }
                    return valid;
                }
                else if(childModel instanceof xfalib.script.Subform &&
                    (childModel.instanceIndex < Math.floor(this.layoutTemplate[cTemplateId].start) ||
                    (childModel.instanceIndex > this.layoutTemplate[cTemplateId].end && this.layoutTemplate[cTemplateId].end > -1))){
                    return false;   //This subform is not in the range of Instances handled by this page. Lying either in earlier or next pages.
                }
            }
            return true;
        },

        _validateHiddenChildLayout : function(childModel){
            if(!childModel.parent)
                return false;       //can happen only for rootsubformview as child model
            var siblings = childModel.parent.children;
            if(siblings && siblings.indexOf(childModel) > 0){
                var childIndex = siblings.indexOf(childModel);
                var lastPaintableSibling = null;
                for(var lastIndex = childIndex-1; lastIndex >=0; lastIndex--){
                    var lastSibling = siblings[lastIndex];
                    if(lastSibling instanceof xfalib.script.InstanceManager){
                        var instanceTemplate = lastSibling._instanceTemplate();
                        var templateId = this.getOrElse(instanceTemplate, "extras.htmlId", null);
                        if(this.layoutTemplate[templateId] != null){
                            if(this.layoutTemplate[templateId].end == -1 && !this.layoutTemplate[templateId].hasLastPartOverflow){
                                //Last layout part of last instance of this IM was here at t0.
                                //So hidden object should come on this page. Else on another page.
                                return true;
                            }
                            else
                                return false;
                        }
                        else
                            continue;   //IM of this hidden sf?.
                    }
                    else if(!this._isPaintable(lastSibling)){
                        continue;
                    }
                    else{
                        lastPaintableSibling = lastSibling;
                        break;
                    }
                }
                if(!lastPaintableSibling){
                    //This hidden child model is first paintable child of this. If this layout element is first part of this model layout
                    // Then hidden child should be painted in this page/view. Else in other view.
                    if(this.getOrElse(this.layoutModel, "occurIndex", 0) == 0)
                        return true;
                    else
                        return false;
                }
                else {
                    //Else if *last part of last paintable sibling* of this hidden node belong to this layout template then this hidden node would also belong here.
                    var lastSiblingValid = this._validateLayoutTemplate(lastPaintableSibling);
                    if(lastSiblingValid){
                        var lastSiblingTemplateId = lastPaintableSibling._templateId();
                        if(!this.layoutTemplate[lastSiblingTemplateId].hasLastPartOverflow)
                            return true;
                        else
                            return false;
                    }
                    else{
                        return false;
                    }
                }
            }
        },

        handleEvent: function(evnt) {
            switch(evnt.name) {
                case xfalib.script.XfaModelEvent.CHILD_ADDED:
                    this.handleChildAdded(evnt);
                    break;
                case xfalib.script.XfaModelEvent.CHILD_REMOVED:
                    this.handleChildRemoved(evnt);
                    break;
                case xfalib.script.XfaModelEvent.CHILD_MOVED:
                    this.handleChildMoved(evnt);
                    break;
                default:
                    xfalib.view.BaseView.prototype.handleEvent.apply(this, arguments);
            }
        },

        handleDomChanged :function(event){
            switch(event._property) {
                default:
                    xfalib.view.BaseView.prototype.handleDomChanged.apply(this,
                        arguments);
            }
        },

        handleModelChanged : function(event) {
            if (event._property == "fillColor") {
                this._fillColor(event.newText);
            }
            else if (event._property == "borderColor") {
                this._borderColor(event.newText);
            }
            /*else if (event._property == "borderWidth") {
                this._borderWidth(event.newText);
            }     */
            else
                xfalib.view.BaseView.prototype.handleModelChanged.apply(this,
                    arguments);
        },

        /*_borderWidth : function(width) {
            $(this.el).css("borderWidth", width)
        },          */

        handleChildAdded : function(event) {
            var addedChild  = event.newText;
            var childTemplateId = addedChild._templateId();
            if(!this.layoutTemplate.hasTemplate || (this.layoutTemplate.hasOwnProperty(childTemplateId) && addedChild.instanceIndex >=  this.layoutTemplate[childTemplateId].start &&
                (this.layoutTemplate[childTemplateId].end < 0 || addedChild.instanceIndex <= this.layoutTemplate[childTemplateId].end))){
                //If added child resides in the range supported by this view, sync it.
                this._syncFormNodeToHtml(false);
            }
            else
                xfalib.runtime.xfa.Logger.debug( "xfaView","This instanceManager has no child in this layout template. This would be handled in other part of splitted subform. el id:"+this._id);
        },

        handleChildMoved : function(event) {
            this._syncFormNodeToHtml(true);
        },

        handleChildRemoved : function(event) {
            var removedChild = event.prevText;
            /*
             * Note/Hack: To get the templateId of removedChild, we can not simply ask child._templateId() as this would return template Id of only those
              * nodes which are still connected to xfa dom. Since remove child is disconnected from xfa, we are asking template Id of this from it's instanceManage
              * which is still there. A workaround for now.
             */
            var childTemplateId = removedChild.instanceManager._instanceTemplate().extras.htmlId;
            if(!this.layoutTemplate.hasTemplate || (this.layoutTemplate.hasOwnProperty(childTemplateId) &&
                (this.layoutTemplate[childTemplateId].end < 0 || removedChild.instanceIndex <= this.layoutTemplate[childTemplateId].end))){
                //If the removed child has instanceIndex less than the end range then there is potential for relayout of this page. So syn it.
                this._syncFormNodeToHtml(false);
            }
            else
                xfalib.runtime.xfa.Logger.debug( "xfaView","This instanceManager has no child in this layout template. This would be handled in other part of splitted subform. el id:"+this._id);
        },

        destroy : function() {
          //TODO: Implement and call destroy method
        },

        _isAnonymous : function() {
            return false;
        },

        _normalizedChildViews : function() {
            var normalizedChildViews = [];
            _.foldl(this.childViews, function(memo, childView, index){
                if(childView instanceof xfalib.view.ContainerView && childView._isAnonymous()){
                    _.each(childView._normalizedChildViews(), function(normalizedChild){
                        memo.push(normalizedChild);
                    });
                }
                else if(!this._isHidden(childView.model)){
                    memo.push(childView);
                }
                return memo;
            }, normalizedChildViews, this);
            return normalizedChildViews;
        },

        _isHidden : function(model){
            //model can be a Node object or simply a json
            if(model && (model.presence == "hidden" || model.presence == "inactive"))
                return true;
            else
                return false;
        },

        _isPaintable : function(model){
            //can this model have visual representation
            if(model && model.isContainer && model.className != "variables")
                return true;
            else
                return false;
        },

        measureSize : function(){
            if(this.layout)
                return this.layout.measureSize();
            else
                return false;
        },

        invalidateSize : function(){
            if(this.layout)
                return this.layout.invalidateSize();
        },

        updateDisplay : function(){
            if(this.layout)
                return this.layout.updateDisplay();
        },

        $elchildren : function(id) {
            return this.$el.children(id);
        }


    });
})(_, $, xfalib);
(function(_, $, xfalib){
    //Intermediate hierarchy to extract out common code for PageView/ContentAreaView/RootSubformView
    xfalib.view.LayoutContainerView = xfalib.view.ContainerView.extend({
        initialize : function(){
            this.growableView = []; // Element that can grow beyond boundary. Current assumption is that there can be only one such element in ContentArea/PageArea
            xfalib.view.ContainerView.prototype.initialize.apply(this, arguments);
        },

        _syncFormNodeToHtml: function(deepSync){
            if(this.childViews == null || this.childViews.length == 0){
                this.childViews = [];
                var that = this;
                var cellIndex = 0;
                if (!this.$el.is(":empty")) {
                    this.childViews = this.$el.children().map(function() {
                        var childView = that._xfaViewRegistry().createView(this, {
                            parentView: that,
                            tableCellIndex : cellIndex,
                            pageNumber: that._pageNumber()
                        });
                        cellIndex = cellIndex + (childView.layoutModel.colspan || 1); //Add the colspan or one
                        if(that._isGrowableView(childView)) {
                            that.growableView.push(childView);
                        }
                        return childView;
                    }).get();
                }
            } else {
                _.each(this.childViews, function(childView){
                    childView.syncFormNodeToHtml(deepSync);
                }, this);
            }
            xfalib.view.BaseView.prototype._syncFormNodeToHtml.apply(this, arguments);   //sync other props before layput
        },

        _isGrowableView :function(childView){
            return false;
        },

        _forceView: function() {
            //this function is to dictate whether the view is forced
            //will be used to force the render of first page at least.
            return false;
        }

    });
})(_, $, xfalib);

(function(_, $, xfalib){
    var SubformView = xfalib.view.SubformView = xfalib.view.ContainerView.extend({

        _assignToolTip: function () {
            var toolTipText = xfalib.ut.XfaUtil.prototype._getToolTipText(this.model);
            // CQ-4222981 : assign tooltip for subform having role as table or it is table
            if (toolTipText && xfalib.ut.XfaUtil.prototype._tableCheckForAccessibility(this)) {
                this.$el.attr("title", toolTipText);
            }
        }

    });

    Object.defineProperty(SubformView.prototype, "resizable", {
        get : function(){
            if(this._resizable)
                return true;
            var layout = this.layoutModel.layout;
            if(layout == xfalib.view.LayoutConst.LAYOUT_LEFTRIGHTTOPBOTTOM || layout == xfalib.view.LayoutConst.LAYOUT_RIGHTLEFTTOPBOTTOM || layout == xfalib.view.LayoutConst.LAYOUT_TOPBOTTOM)
                return true;
            else
                return false;
        },

        set : function(sValue){
            this._resizable = sValue;
        }
    });

})(_, $, xfalib);(function(_, $, xfalib){
    var SubformSetView = xfalib.view.SubformSetView = xfalib.view.ContainerView.extend({
        initialize : function() {
            xfalib.view.ContainerView.prototype.initialize.apply(this, arguments);
        },

        _isAnonymous : function() {
            return true;
        },

        $computeWH : function(){
            var extent = {};
            return extent;
        },

        _computeExtent : function() {
            //mark the position of the subformset as transparent
            var extent = xfalib.view.ContainerView.prototype._computeExtent.apply(this, arguments);
            extent['position'] = 'static';
            return extent
        }
    });
})(_, $, xfalib);(function(_, $, xfalib){
    xfalib.view.ContentAreaView = xfalib.view.LayoutContainerView.extend({
        _isGrowableView :function(childView){
            return (childView.model === this._formDomRoot().form.children[0]); // Is root subform of the form dom
        },

        _initializeLayoutModel : function(){
            xfalib.view.LayoutContainerView.prototype._initializeLayoutModel.apply(this, arguments);
            //Special handling for enabling shrink page functionality. We'll treat contentArea as TopBotton flowable subform.Bug#3608773
            this.layoutModel.extentactualh = -1;
            this.resizable = true;
        }

    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.PageView = xfalib.view.LayoutContainerView.extend({

        initialize : function() {
            xfalib.view.LayoutContainerView.prototype.initialize.apply(this, arguments);
            /* Flag indicating that the tabbing computation for this Page would be redone */
            this._tabComputePending = false;
        },

        _initLayout : function(){
            xfalib.view.LayoutContainerView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                /* When a Page View is initialized, immediately mark it for tab compute*/
                this.invalidateTabIndex();
            }
        },

        _forceView: function() {
            //this function is to dictate whether the view is forced
            //will be used to force the render of first page at least.
            return this._pageNumber() == 1;
        },

        _isGrowableView :function(childView){
            return (childView instanceof xfalib.view.ContentAreaView);
        },

        _pageNumber : function(){
            /* Return the page number that was sent from server. Page Number starts with 1.*/
            if(this.layoutModel){
                return this.layoutModel.pageNumber;
            }
            return -1;
        },

        _computeExtent : function(){
            var extent = xfalib.view.LayoutContainerView.prototype._computeExtent.apply(this, arguments);
            extent["position"] = "relative";
            extent["margin-left"] = "auto";               //We need to mark page margins to auto to adjust pages with different master page layout
            extent["margin-right"] = "auto";
            extent["margin-bottom"] = 10;
            extent["margin-top"] = this._pageNumber() == 1 ? 0 : 10 ;
            return extent;
        },

        /*
         * Marks/Queues the Page for re-compute of tab indexes. Re-computation would automatically be fired
         * asynchronously.
         */
        invalidateTabIndex : function(forceCompute) {
            if(!this._tabComputePending || forceCompute){
                /*
                 * Tab compute invalidation sets the tabComputePending flag to true and then fires actual computation async
                 * way in-order for cases where simultaneous in-validations may occur multiple times for different
                 * fields or repeatable subform of the same page. In those cases, we want to compute tab indexes only once when
                 * everything is done.
                 * Another thing, if there is any layout computation pending in layout manager, we defer the tab computation till
                 * that is complete since x,y can change in those cases.
                 **/
                this._tabComputePending = true;
                var that = this;
                xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(
                    window.setTimeout(function(){
                        if(!that._layoutManager.isLayoutCycleComplete()){
                            //layout cycle running so do a force invalidation to defer tab computation to next cycle
                            that.invalidateTabIndex(true);
                        }
                        else{
                            that._computeTabIndex();
                        }
                    }, 1)
                );
            }
        },

        _computeTabIndex : function () {
            this._tabComputePending = false;
            xfalib.view.util.traversalManager._computTabIndex(this);
        }

    });
})(_, $, xfalib);
(function (_, $, xfalib) {
    xfalib.view.RootSubformView = xfalib.view.LayoutContainerView.extend({
        initialize: function () {
            var pagingConfig = this._xfaViewRegistry().pagingConfig();
            this.$el = (this.options.el instanceof $) ? this.options.el : $(this.options.el);
            //make paging default
            if (pagingConfig.pagingDisabled) {
                _.each(this.options.restOfThePages, function (pageEl) {
                    // removed creation of extra page view as childView, on containerView initialize we anyways initialize childView as empty array
                    // on syncFormNodeToHtml we are using $el.children() to create new child views
                    // so just appending rest of the pages element should be enough
                    this.$el.append(pageEl);
                }, this);

            }
            else if (this.options && this.options.restOfThePages) {
                //do nothing, just mark rest of the pages as deferred pages
                this._deferredPages = this.options.restOfThePages;
            }

            this.totPages = this.getOrElse(this, "options.restOfThePages.length", 0) + 1;  // todo: fix this when initial count is present
//            console.profile("P1");
            xfalib.view.LayoutContainerView.prototype.initialize.apply(this, arguments);
//            console.profileEnd();

            //Bug#3670373: a custom event is triggered after the first page is loaded.
            var _triggerXfaFirstPgLayoutComplete = function () {
                this.childViews[0].off('layoutComplete', _triggerXfaFirstPgLayoutComplete);
                $(window).trigger('xfaFirstPgLayoutComplete');
                this._xfaViewRegistry().scaleForm();
            };
            this.childViews[0].on('layoutComplete', _triggerXfaFirstPgLayoutComplete, this);

            //accessibility
            //add form role to rootSubformView
            this.$el.attr("role", "form");

            //also add lang attribute in it
            //leap of faith -- getting the rootsubform of the form model and then set the lang attribute
            if (xfalib.runtime.form.children[0] && xfalib.runtime.form.children[0].jsonModel && xfalib.runtime.form.children[0].locale) {
                //add lang parameter
                var lang = this._langFromLocale(xfalib.runtime.form.children[0].locale);

                if (lang && lang.length > 0) {
                    this.$el.attr("lang", lang);
                }
            }

        },

        _computeExtent: function () {
            return {};
        },

        renderDeferredPage: function () {
            //assert(userConfig && userConfig.pagingConfig && userConfig.pagingConfig.pagingEnabled);
            if (this.hasMoreDeferredPages()) {                              //just make sure we have more than 10 bytes
                //create dom here
                var nextPageEl = $(this._deferredPages.shift());
                var nextPageView = this._xfaViewRegistry().createView(nextPageEl, {parentView: this});
                this.$el.append(nextPageEl);
                this.childViews = this.childViews || [];
                this.childViews.push(nextPageView);
                xfalib.ut.XfaUtil.prototype._triggerOnBridge("elementPageRendered", xfalib.runtime.xfa.form.form1, "nextPage", this.childViews.length-1, this.childViews.length);
                //this.childViews.length-1 is the page number till which form is already rendered
                //this.childViews.length indicates the page number of current page rendered
                //if(window.highlight)
                //    highlightFields();
                return nextPageView;
            }
            return null;
        },

        hasMoreDeferredPages: function () {
            return (this.getOrElse(this._deferredPages, []).length > 0);
        }
    });
})(_, $, xfalib);
(function(_, $, xfalib){
    xfalib.view.ExclGroupView = xfalib.view.ContainerView.extend({
        initialize : function(){
            xfalib.view.ContainerView.prototype.initialize.apply(this, arguments);
            $(this.$el).on(xfalib.ut.XfaUtil.prototype.XFA_CLICK_EVENT,
                                         $.proxy(this.handleClickEvent,this));
        },

        handleClickEvent : function() {
            //this.model.execEvent("click");
        },

        _getScreenReaderText : xfalib.view.FieldView.prototype._getScreenReaderText,

        _assignToolTip : xfalib.view.FieldView.prototype._assignToolTip,

        _initLayout : function(){
            xfalib.view.ContainerView.prototype._initLayout.apply(this, arguments);
            if(this._initialized){
                this.markMandatory();
                this.$el.attr("role", "radiogroup"); //add role
            }
        },

        markMandatory : function(){
            if(this.model.mandatory== "error")
                if(this.$el)
                    this.$el.attr("data-mandatory", "true") ;
        },

        handleModelChanged : function(event) {
            switch (event._property) {
                case "focus":
                    var childView = this._getChildToFocus();
                    this._focusWidget(childView);
                    break;
                case "ValidationState":
                    this._markError(event);
                    break;
                case "ClearError":
                    this._clearError(event);
                    break;
                default:
                    xfalib.view.ContainerView.prototype.handleModelChanged.apply(this, arguments);
            }
        },

        handleDomChanged: function (event) {
            switch (event._property) {
                case "nullTest":
                    xfalib.view.FieldView.prototype._handleNullTest.call(this, event, this.$el.closest('.exclgroup'));
                    break;
                default:
                    xfalib.view.ContainerView.prototype.handleDomChanged.apply(this, arguments);
            }
        },

        _handleMandatory: xfalib.view.FieldView.prototype._handleMandatory,
        _handleDisabled: xfalib.view.FieldView.prototype._handleDisabled,

        _markError : function(evnt) {
            this.$el.addClass("widgetError");
        },

        _clearError : function(evnt) {
            this.$el.removeClass("widgetError");
        },

        /*
         * @function
         * get child view of exclusion group which needs to be focussed.
         */
        _getChildToFocus : function () {
            return _.find(this.childViews, function (childView) {
                var model = childView.model;
                return (model && model.presence == "visible" && model.mEffectiveAccess == "open");
            });
        }
    });
})(_, $, xfalib);
/**
 * Created with IntelliJ IDEA.
 * User: rpandey
 * Date: 12/24/12
 * Time: 8:14 PM
 * To change this template use File | Settings | File Templates.
 */
(function(_, $, xfalib){
    xfalib.view.SignatureFieldView = xfalib.view.FieldView.extend({
        _createPluginOptions : function() {
            var vOptions = xfalib.view.FieldView.prototype._createPluginOptions.apply(this,
                arguments);
            return vOptions;
        },

        _createDefaultWidgetPlugin : function(options) {
            $(this.widget).signatureField(options);
            this.jqWidget = this.$data(this.widget, "xfaWidget-signatureField");
        }

    });
})(_, $, xfalib);(function (_, $, xfalib) {

    xfalib.view.PagingManager = xfalib.view.ObjectView.extend({

        initialize: function () {
            xfalib.view.ObjectView.prototype.initialize.call(this);
            this.autoRenderPageHandler = null;
            this._autoPageRenderPending = false;
        },

        renderNextPage: function () {
            var that = this;
            var pageView = this._getRootView().renderDeferredPage();
            if (pageView) {
                pageView.on("layoutComplete",
                    function (event) {
                        that.trigger("newPageRender");
                        this._xfaViewRegistry().scaleForm();
                    }
                );
            }
            return pageView;

        },

        autoRenderPage: function () {
            if (this.autoRenderPageHandler) {
                //Ideally autoRenderPageHandler should be postponed till all running layout/display validation cycles are finished and
                //there is no pending layout validation. For now we are doing it in next script cycle/setTimeout.
                var autoRenderHandler = this.autoRenderPageHandler;
                xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(window.setTimeout(autoRenderHandler, 1));
                this._autoPageRenderPending = false;
            }
            else {
                this._autoPageRenderPending = true;
            }
        },

        setAutoRenderPageHandler: function (value) {
            if (this.autoRenderPageHandler != value) {
                this.autoRenderPageHandler = value;
                if (this.autoRenderPageHandler && this._autoPageRenderPending) {
                    this.autoRenderPage();
                }
            }
        },

        hasMorePages: function () {
            return this._getRootView().hasMoreDeferredPages();
        },

        _getRootView: function () {
            return this._xfaViewRegistry().rootSubformView;
        },

        pageCount: function () {
            return (this._getRootView().totPages || 1);
        },

        _makePage: function (pageNum) {
            if (pageNum > this.pageCount()) {
                pageNum = this.pageCount();
            }
            if (pageNum > this.currentPage()) {
                var extPageCounts = pageNum - this.currentPage();
                for (var i = 0; i < extPageCounts; i++) {
                    this.renderNextPage();
                }
            }
            return true;
        },

        currentPage: function () {
            var b = this._getRootView().childViews;
            if (xfalib.view.FieldView.prototype.currentFocus) {
                var a = $(xfalib.view.FieldView.prototype.currentFocus.el).parents(".page")[0];
                //TODO: Try to do without for Loop
                for (var i = 0; i < b.length; i++)
                    if (b[i].el == a)
                        return i;
            }
            return 0;
        },

        pageDown: function () {
            if (this._getRootView().hasMoreDeferredPages()) {
                var pageView = this.renderNextPage();
                this._pageDown(pageView);

            }
            else
                this._pageDown();


        },


        _pageDown: function (pageView) {
            var nextPage = this.currentPage() + 1;
            var a = $($(".page")[nextPage]);
            window.scrollTo(0, a.offset().top);
            pageView.off("layoutComplete",
                function (event) {
                    that._pageDown();
                }
            );
        },

        _makePageForHtmlId: function (htmlId, callback, context) {
            if (htmlId == null)
                return false;
            var nodeSelector = this.jqId(htmlId);
            var rootView = this._getRootView();
            var nodeElArray = rootView.$el.find(nodeSelector);
            if (nodeElArray.length > 0) {
                if (callback)
                    callback.apply(context);
                return true;
            }


            var pageFound = false;
            while (this.hasMorePages()) {
                var view = rootView.renderDeferredPage();
                if (view.$el.find(nodeSelector).length > 0) {
                    if (callback)
//LC-4424 We are sending the event layoutComplete that the layout is complete from our view point but the
// browser has not yet painted the page( Chrome) and hence the focus is coming at the wrong place.
                        view.on("layoutComplete", function () {
                            xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(
                                window.setTimeout(function () {
                                    callback.apply(context);
                                })
                            );
                        });
                    pageFound = true;
                    break;
                }
            }
            if (pageFound)
                return true;
            else
                return false;
        },

        findPage: function (htmlId) {
            if (htmlId == null)
                return false;
            var nodeSelector = this.jqId(htmlId);
            var rootView = this._getRootView();
            var i = 0;
            for (; i < rootView.childViews.length; i++) {
                var nodeElArray = $(rootView.childViews[i].el).find(nodeSelector);
                if (nodeElArray.length > 0) {
                    return i;
                }
            }
            while (this.hasMorePages()) {
                rootView.renderDeferredPage();
                var nodeElArray = $(rootView.childViews[i].el).find(nodeSelector);
                if (nodeElArray.length > 0) {
                    return i;
                }
                i++;
            }
        },

        getLayout: function (htmlId) {
            if (htmlId == null)
                return false;
            var nodeSelector = this.jqId(htmlId);
            var rootView = this._getRootView();
            var el = rootView.$el.find(nodeSelector);
            if (el.get(0)) {
                var layout = this.getOrElse(this.$data(el.get(0), "xfaView"), {});
                return layout.layoutModel;
            }
            else return null;

        },

        _pageContent: function (pageNum, className, bPageArea) {
            bPageArea = bPageArea || false;
            this._makePage(pageNum);
            var pageView = this._getRootView().childViews[pageNum];
            var contentList = new xfalib.script.XfaList();
            if (pageView.model && (!className || className == "pageArea")) {
                contentList._append(pageView.model);
            }
            if (!bPageArea) {
                for (var pv in pageView.childViews) {
                    if (pageView.childViews[pv] instanceof  xfalib.view.ContentAreaView) {
                        contentList._concat(this.$pageContent(pageView.childViews[pv], className, bPageArea));   //Rather than passing the pageArea, we are passing only contentArea
                        // so that it returns all non-pageArea content nodes
                    }

                }
                return contentList;
            }
            contentList._concat(this.$pageContent(pageView, className, bPageArea));
            return contentList;
        },

        $nodeContent: function (node, className, bPageArea) {
            //process child nodes
            var contentList = new xfalib.script.XfaList();
            if (node) {
                _.each(node.children, function (nodeChild) {
                    if (!className && nodeChild.isContainer) {
                        contentList._append(nodeChild);
                    }
                    else if (nodeChild.className == className) {
                        contentList._append(nodeChild);
                    }

                    if (nodeChild.isContainer) {
                        var nodeChildContentList = this.$nodeContent(nodeChild, className, bPageArea);
                        contentList._concat(nodeChildContentList);
                    }
                }, this);
            }
            return contentList;
        },

        $pageContent: function (view, className, bPageArea) {

            var contentList = new xfalib.script.XfaList();
            //process child nodes
            if (bPageArea && view instanceof xfalib.view.ContentAreaView)
                return contentList;      // Breaking the recursion here, so that it will return only pageArea content nodes
            _.each(view.childViews, function (childView) {
                if (childView.model) {
                    var childModel = childView.model;
                    if (!className && childModel.isContainer) {
                        contentList._append(childModel);
                    } else if (childModel.className == className) {
                        contentList._append(childModel);
                    }
                }
                //Time to recurse

                if (childView._isPlaceHolderEl() && childView.model) {
                    //For hidden views that have never been initialized, we would want to return all contained nodes since we stitch
                    //hidden node together in first page.
                    contentList._concat(this.$nodeContent(childView.model, className, bPageArea));
                }
                else {
                    contentList._concat(this.$pageContent(childView, className, bPageArea));
                }

            }, this);
            return contentList;
        }

    });
})(_, $, xfalib);
(function(_, $, xfalib){

        xfalib.view.DataTableView = xfalib.view.ContainerView.extend({

        $elchildren : function(id) {
            return this.$el.children().children(id);
        },

        _getScreenReaderText: xfalib.view.FieldView.prototype._getScreenReaderText,

        _assignToolTip : xfalib.view.FieldView.prototype._assignToolTip

        });
})(_, $, xfalib);
(function(_, $, xfalib){
    var root = window;
    root.xfaViewRegistry = (function(){
        var _templateCache = new xfalib.view.util.HtmlTemplateCache();
        var _layoutManager = new xfalib.view.layout.LayoutManager();
        var xfaUtil = xfalib.ut.XfaUtil.prototype;

        var _viewTypeRegistry = {
            BaseView : xfalib.view.BaseView,
            FieldView : xfalib.view.FieldView,
            NumericFieldView : xfalib.view.NumericFieldView,
            ChoiceListFieldView : xfalib.view.ChoiceListFieldView,
            ObjectView : xfalib.view.ObjectView,
            SubformView : xfalib.view.SubformView,
            SubformSetView : xfalib.view.SubformSetView,
            PageView : xfalib.view.PageView,
            ContentAreaView : xfalib.view.ContentAreaView,
            RootSubformView : xfalib.view.RootSubformView,
            ContainerView : xfalib.view.ContainerView,
            ButtonFieldView : xfalib.view.ButtonFieldView,
            CheckButtonFieldView : xfalib.view.CheckButtonFieldView,
            TextFieldView : xfalib.view.TextFieldView,
            SignatureFieldView : xfalib.view.SignatureFieldView,
            ImageFieldView : xfalib.view.ImageFieldView,
            XfaDrawView : xfalib.view.XfaDrawView,
            DateTimeFieldView: xfalib.view.DateTimeFieldView,
            ExclGroupView: xfalib.view.ExclGroupView,
            DataTableView: xfalib.view.DataTableView
        };

        var _defaultDraw = {
            view : _viewTypeRegistry.XfaDrawView
        };

        var _defaultField = {
            view : _viewTypeRegistry.FieldView,
            widgetTemplate : null,
            viewInitConfig : {
                commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                commitProperty : "value",
                commitTarget : "rawValue"
            }
        };
        var _defaultContainer = {
            view : _viewTypeRegistry.ContainerView
        };
        var _defaultDataTable = {
            view : _viewTypeRegistry.DataTableView
        };

        var _nodeTypeRegistry = {
            //Containers
            "area" :    _defaultContainer,
            "contentarea" : {view : _viewTypeRegistry.ContentAreaView},
            "exclgroup" : {view : _viewTypeRegistry.ExclGroupView},
            "page" : {view : _viewTypeRegistry.PageView},
            "subform" : {view : _viewTypeRegistry.SubformView},
            "subformset" : {view : _viewTypeRegistry.SubformSetView},
            "rootsubform" : {view : _viewTypeRegistry.RootSubformView},

            //Fields
            "textfield" : {
                view : _viewTypeRegistry.TextFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "signaturefield" : {
                view : _viewTypeRegistry.SignatureFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "textareafield" : {
                view : _viewTypeRegistry.TextFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "numericfield" : {
                view : _viewTypeRegistry.NumericFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "imagefield" : {
                view : _viewTypeRegistry.ImageFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    commitProperty : "src",
                    commitTarget : "rawValue"
                }
            },
            "datefield" : {
                view : _viewTypeRegistry.DateTimeFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_EXIT_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "timefield" : _defaultField,
            "datetimefield" : _defaultField,
            "passwordfield" : _defaultField,
            "buttonfield" : {
                view : _viewTypeRegistry.ButtonFieldView,
                viewInitConfig : {
                    commitEvent : null,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "submitfield" : _defaultDraw,
            "radiofield" : {
                view : _viewTypeRegistry.CheckButtonFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "checkboxfield" : {
                view : _viewTypeRegistry.CheckButtonFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            },
            "choicelist" : {
                view : _viewTypeRegistry.ChoiceListFieldView,
                viewInitConfig : {
                    commitEvent : xfalib.ut.XfaUtil.prototype.XFA_CHANGE_EVENT,
                    commitProperty : "value",
                    commitTarget : "rawValue"
                }
            }
        };


        return {
            viewTypeRegistry : _viewTypeRegistry,
            rootSubformView : null,
            nodeTypeRegistry : _nodeTypeRegistry,
            _userConfig : null,

            widgetConfig : function(){
                if(this._userConfig && this._userConfig["widgetConfig"]){
                    return this._userConfig["widgetConfig"];
                }
            },

            pagingConfig : function(){
                if(this._userConfig && this._userConfig["pagingConfig"]){
                    return this._userConfig["pagingConfig"];
                }
                var shrinkPageDisabledValue = false;
                if(this._userConfig && this._userConfig["behaviorConfig"]){
                    //TODO: Create a generic method somewhere in FormBridge?
                    var version = new xfalib.ut.Version(this._userConfig["behaviorConfig"]);
                    if(version.isPreviousOrSame(version.ES4))
                        shrinkPageDisabledValue = true;
                }

                return {
                    pagingDisabled : false,
                    shrinkPageDisabled : shrinkPageDisabledValue
                };
            },

            lookUpView : function(options){
                options = options || {};

                if(options.dataTable)
                    return _defaultDataTable;
                var nodeTypeView = this.nodeTypeRegistry[options.nodeType];
                if(nodeTypeView)
                    return nodeTypeView;

                if(options.field)
                    return _defaultField;
                else if(options.draw)
                    return _defaultDraw;
                else
                    return _defaultContainer;
            },

            createView : function(htmlDomNode, options){
                var $htmlDomNode = $(htmlDomNode);
                var nodeType = (xfaUtil.$data($htmlDomNode.get(0), xfalib.view.LayoutConst.XFA_MODEL) ||{})[xfalib.view.LayoutConst.NODE_TYPE];
                var isField = $htmlDomNode.hasClass("field");
                var isDraw = $htmlDomNode.hasClass("draw");
                var isDataTable = ($htmlDomNode.prop("tagName") == "TABLE");
                var isDataTableRow = ($htmlDomNode.prop("tagName") == "TR");
                var isDataTableCell = ($htmlDomNode.prop("tagName") == "TD" || $htmlDomNode.prop("tagName") == "TH" );
                var viewOptions = {
                    "nodeType" : nodeType,
                    "field" : isField,
                    "draw" : isDraw,
                    "dataTable" : isDataTable,
                    "dataTableRow" : isDataTableRow,
                    "dataTableCell" : isDataTableCell
                };
                var viewConfig = this.lookUpView(viewOptions);
                var initParam =  _.extend(
                    {el:htmlDomNode},
                    viewConfig["viewInitConfig"],
                    options
                );
                var viewInstance =  new viewConfig["view"](initParam);
                return viewInstance;
            },

            /**
             * Clears the template cache. The API is needed to clear the cache when
             * unloading one form and loading another form in Form Set.
             */
            clearTemplateCache: function () {
                _templateCache = new xfalib.view.util.HtmlTemplateCache();
            },

            /**
             * Clears the Layout Manager. The API is needed to unload the layout Manager
             * when unloading one form and loading another form in Form Set.
             */
            resetLayoutManager : function () {
              _layoutManager = new xfalib.view.layout.LayoutManager();
            },

            /**
             * The function is used to destroy the resources held by the object.
             * This function is called when the form is destroyed.
             */
            destroy: function () {
                _templateCache = undefined;
                _layoutManager = undefined;
            },

            templateCache : function(){
                return _templateCache;
            },

            layoutManager : function(){
                return _layoutManager;
            },


            /*
             * look ups the formWidth value in behaviourConfig; and if browser supports scaling, enforce that width by scaling the form
             */
            scaleForm: function () {
                var formWidth = this._userConfig["viewportWidth"];
                if (formWidth) {
                    var timeout = window.setTimeout(function () {     // wait for enough time to let layout complete
                        formWidth = parseInt(formWidth);
                        var pageMaxWidth = 0;
                        $(".page").each(function (i, obj) {
                            var tmpWidth = parseInt($(obj).width());
                            if (tmpWidth > pageMaxWidth)
                                pageMaxWidth = tmpWidth;
                        });
                        var width = pageMaxWidth,
                            height = parseInt($("body").height()),
                            scaleFactor = xfalib.ut.XfaUtil.prototype.formScaleFactor = formWidth / width,
                            transformValue = "scale(" + scaleFactor + ")",
                            marginHeight = height - scaleFactor * height,
                            marginWidth = width - scaleFactor * width,
                            scaleStyles = {
                                "-webkit-transform": transformValue, /* Saf3.1+, Chrome */
                                "-moz-transform": transformValue, /* FF3.5+ */
                                "-ms-transform": transformValue, /* IE9 */
                                "transform": transformValue,
                                "-webkit-transform-origin": "0 0",
                                "-moz-transform-origin": "0 0",
                                "-ms-transform-origin": "0 0",
                                "transform-origin": "0 0",
                                /* below two values are based on total heuristics. best combination to get thing working cross browser:
                                 *  In few browsers, after scaling there is blank space on bottom so margin-bottom is used with negative value.
                                 *  margin right is required for removing space on right in few browser, after scaling.
                                 *  And interestingly, formulae for both are different, not my mistake- total heuristics.
                                 *  IE still has space left in bottom&right in scaled down version but works good in scale up version.
                                 *  New, step would be to make these values per browser type. But common for now.
                                 * */
                                "margin-bottom": Math.min(0, -1 * marginHeight),
                                "margin-right": -1 * marginWidth
                            }
                        $("body").css(scaleStyles);
                        $(".page").css("margin", 0);
                        /*dispatch event so that toolbar and other widths can be re-computed.*/
                        $(window.formBridge).trigger("xfaFormScale");
                    }, 100);
                    xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(timeout);
                }
            },

            /*
             * Invalidates tab indexes for given page number. Note that page number starts with one.
             */
            invalidateTabIndex : function(pageNum){
                if(pageNum > -1 && this.rootSubformView && this.rootSubformView.childViews ){
                    var pageView = this.rootSubformView.childViews[pageNum -1];
                    if(pageView){
                        pageView.invalidateTabIndex();
                    }
                }
            }
        };
    })();

    root.xfaViewRegistry.initializeView = function(firstPageHtmlStr, restOfThePages){
        var viewStartTime = Date.now();
        var $formHtml = $(firstPageHtmlStr);
        var options = {};
        options.restOfThePages = restOfThePages;
        var pagingManager = new xfalib.view.PagingManager();
        xfalib.runtime.xfa.host.pagingManager = pagingManager;
        xfalib.runtime.xfa.$layout.pagingManager = pagingManager;
        window.xfaViewRegistry.rootSubformView = window.xfaViewRegistry.createView($formHtml, options);
        xfalib.runtime.xfa.host.on(xfalib.script.XfaModelEvent.FORM_MODEL_REFRESH,{
            handleEvent: function(evnt) {
                switch(evnt.name) {
                    case xfalib.script.XfaModelEvent.FORM_MODEL_REFRESH:
                        window.xfaViewRegistry.rootSubformView.syncFormNodeToHtml(true);
                        break;
                    default:
                    /* log an error message */
                }
            }
        });
        //TODO: move this to Logger
        formBridge.viewTime = Date.now()-viewStartTime;
        xfalib.runtime.xfa.Logger.debug("xfaView","################ total time to create view:"+formBridge.viewTime);
        return $formHtml;
    };

    root.xfaViewRegistry.initializeModel = function(xfaJson, xfaDataMergeDorm, xfalocaleset, xfarendercontext) {
        //read renderContext and other xfa specific node and push it
        xfalib.runtime.renderContext = xfarendercontext;

        if(xfalib.ut.XfaUtil.prototype.getOrElse(xfalib.runtime, "customPropertyMap.xmlOnClient", "0") === "1") {
            if(xfalib.runtime.renderContext.data) {
                formBridge.playDataXML({
                    xmlDocument : xfalib.runtime.renderContext.data
                });
            }
        }
        //read localeset as well
        xfaJson.localeSet = xfalocaleset;

        //Create Xfa Node
        xfalib.script.XfaModelRegistry.prototype.createModel(xfaJson);       //TODO: Handle window dependency

        if(xfalib.runtime.xfa.Logger.isLogEnabled("xfa", xfalib.ut.Logger.prototype.TRACE)){
            xfalib.runtime.xfa.Logger.trace("xfa","################ t0 xfadom:\n" + JSON.stringify(xfaJson));
        }

        var hasRestoreState = false;
        if (window.formBridge != undefined) {
            var localStorage = window.formBridge._getStorage();
            if (localStorage && localStorage.xfaDom) {
                xfaJson = JSON.parse(localStorage.xfaDom);
                if(xfaJson) {
                    hasRestoreState = true;
                    if(xfalib.runtime.xfa.Logger.isLogEnabled("xfa", xfalib.ut.Logger.prototype.TRACE)){
                        xfalib.runtime.xfa.Logger.trace("xfa","################ restore xfadom:\n" + JSON.stringify(xfaJson));
                    }
                    xfalib.runtime.xfa.host.playJson(xfaJson);
                }
            }
            var xmlStorage = window.formBridge._getXmlStorage();
            if(xmlStorage) {
                xfalib.runtime.xfa.Logger.trace("xfa","################ restore xml:\n" + xmlStorage);
                try {
                    xfalib.runtime.xfa.host.playDataXml(xmlStorage);
                } catch(exception) {
                    xfalib.runtime.xfa.Logger.error("xfa", "restoring xml failed ")
                    if(_.isFunction(formBridge.xmlStorage.error)) {
                        var resObj = formBridge._getResultObject();
                        resObj.addMessage(2, exception, null);
                        formBridge.xmlStorage.error.apply(formBridge.xmlStorage.context, [resObj])
                        //to ensure that success handler is not called after form render from FormBridge._xfaInitialized
                        formBridge.xmlStorage.success = null;
                    }
                }
            }
        }
        if( xfalib.ut.XfaUtil.prototype.getOrElse(xfalib.runtime, "customPropertyMap.xmlOnClient", "0") !== "1") {
            if(!hasRestoreState && xfaDataMergeDorm){
                if(xfalib.runtime.xfa.Logger.isLogEnabled("xfa", xfalib.ut.Logger.prototype.TRACE)){
                    xfalib.runtime.xfa.Logger.trace("xfa","################ restore xfadom:\n" + JSON.stringify(xfaDataMergeDorm));
                }
                xfalib.runtime.xfa.host.playJson(xfaDataMergeDorm);
            }
        }
        if( xfalib.ut.XfaUtil.prototype.getOrElse(xfalib.runtime, "customPropertyMap.destroyOnExit", "0") === "1") {
            $(window).on("beforeunload.xfa", function () {
                formBridge.destroyForm(true);
            });
        }
    };

    root.xfaViewRegistry.initializeFormOnDomReady = function() {
        $(function($){
            try {
                var initStart = Date.now();
                //initialize Acrobat specific scripts
                new xfalib.acrobat.Acrobat();
                if(xfalib.runtime.xfa) {
                    xfalib.runtime.xfa.form._initialize(true);
                    $(window).trigger("XfaInitialized");
                }
                formBridge.modelInitTime = Date.now()-initStart;
                xfalib.view.FieldView.prototype.currentFocus = null;
                $(window).on("mousedown.xfa", function() {
                    formBridge.clickedOnWindow = true;
                });
            } catch(e) {
                xfalib.runtime.xfa.Logger.error("xfa","error in form._initialize");
                if(e.stack){
                    xfalib.runtime.xfa.Logger.error("xfa", e.stack);
                }
            }
        });
    };

    //TODO: Put below call at proper place
    window._initializeXfaLoading = function (xfaJson, xfaDataMergeDorm, xfalocaleset, xfarendercontext, fileAttachmentMap) {
        window.formBridge._postExternalMessage({name : "_formdomstart"});
        var xfaModelLoadStart = Date.now();
        var xfaViewRegistry = window.xfaViewRegistry;

        //read internal css and attach it to head
        //excuse m
        if($('#formLoadingDiv').data('internalcss')) {
            var internalcss = $('#formLoadingDiv').data('internalcss'),
                styleTag = '<style id="mfstyle" type="text/css">'+internalcss+'</style>';
            //insert internal css before the first style element.
            if($('head>style:first').length > 0)
                $('head>style:first').before(styleTag);
            else if($('head').length > 0)
                $('head').append(styleTag);
            else if($('body').length > 0)
                $('body').prepend(styleTag);
            else if($('html').length > 0)
                $('html').prepend(styleTag);
            else
                $('#formLoadingDiv').prepend(styleTag);
        }

        xfaViewRegistry.initializeModel(xfaJson, xfaDataMergeDorm, xfalocaleset, xfarendercontext);

        window.formBridge._postExternalMessage({name : "_layoutstart"});
        xfaViewRegistry._userConfig = window.formBridge.userConfig;
        //TODO: move this to Logger
        formBridge.modelTime = Date.now()-xfaModelLoadStart;
        xfalib.runtime.xfa.Logger.debug("xfaView","################ total time to load xfa model:"+ formBridge.modelTime);

        xfalib.runtime.xfa.form.mbInitialized = false;

        var xfahtmldom =  $('#formLoadingDiv').data('xfahtmldom');
        var xfaresthtmldom = $('#formLoadingDiv').data('xfaresthtmldom');
        var xfahiddenobjdom = $('#formLoadingDiv').data('xfahiddenobjdom');

        xfalib.runtime.xfa.Logger.trace("xfaView","################ xfahtmldom:\n" + xfahtmldom);
        xfalib.runtime.xfa.Logger.trace("xfaView","################ xfaresthtmldom:\n" + xfaresthtmldom);
        xfalib.runtime.xfa.Logger.trace("xfaView","################ xfahiddenobjdom:\n <a>" + xfahiddenobjdom + "</a>");

        xfaViewRegistry.templateCache().setHiddenObjPages(xfahiddenobjdom); //cache the pages with hidden object layout
        $('#formLoadingDiv').replaceWith(xfaViewRegistry.initializeView( xfahtmldom, xfaresthtmldom));

        xfalib.runtime.xfa.Logger.debug("xfaView","################ total time to load xfa model + view:"+(Date.now()-xfaModelLoadStart));
        window.formBridge._postExternalMessage({name : "_layoutend"});

        xfaViewRegistry.initializeFormOnDomReady();

        xfalib.runtime.xfa.form.mbInitialized = true;

        // Restore attachments
        // We are setting this which is passed by file attachment plugin to  the fileUpload widget
        // as options.value and then widget creation takes place
        if(xfalib.runtime) {
            xfalib.runtime.fileAttachment = fileAttachmentMap;
        }

    };

})(_, $, xfalib);
/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
(function ($) {

    function highlightFields() {
        $(".widget:not(.buttonfieldwidget,.submitfieldwidget)")
            .toggleClass("widgetBackGroundColorHighlight", xfalib.globals.highlight);
        $(".widget[data-mandatory='true'],.exclgroup[data-mandatory='true']")
            .toggleClass("widgetMandatoryBorder", xfalib.globals.highlight);
    }

    function _getToolbarWidth() {
        var _tbwidth = document.body.clientWidth;
        if (window.formBridge && window.formBridge.userConfig["viewportWidth"]) {
            _tbwidth = window.formBridge.userConfig["viewportWidth"];
        }
        $(".page").each(function (i, obj) {
            var extent = {};
            var tmpWidth = parseInt($(this).width());
            if (tmpWidth > _tbwidth)
                _tbwidth = tmpWidth;
        });
        return _tbwidth - 2;
    }

    function _setToolbarWidth() {
        var extent = {};
        extent["width"] = _getToolbarWidth();
        $(".toolbarheader").css(extent);
        $(".pagingfooter").css(extent);
        $(".toolbarheader").css("left", "0px");
        $(".toolbarheader").css("right", "0px");
    }

    //show toolbar button based on logger.
    window.formBridge.connect(
        function () {
            $("#loadingPage").hide();
            if (xfalib.runtime.xfa.Logger.isServerLoggingEnabled()) {
                $("#toolbarloggerbtn").css({display: "inline-block"});
                //register click handler to send logs
                $("#toolbarloggerbtn").click(function () {
                    xfalib.runtime.xfa.Logger.serverHandler();
                });
            }
        }
    );

    $(window).one('xfaFirstPgLayoutComplete', function() {
        $("#loadingPage").hide();
        $(".loadingBody").removeClass("loadingBody");
    });

    //register when document is ready
    $(function ($) {

        var toolBarInit = function () {
            _setToolbarWidth();
            highlightFields();

            $(window).on('resize', _setToolbarWidth); // Bug#3670394 : changed $('body') to $(window)
            $(formBridge).on('xfaFormScale', _setToolbarWidth); // rescale the toolbar
            try {
                window.parent.addEventListener('orientationchange', function () {
                    window.xfaViewRegistry.scaleForm();
                });
            }
            catch (e) {
                xfalib.runtime.xfa.Logger.error("xfa", "could not register orientationchange listener");
            }

            $(formBridge).on("xfaNextPageRendered xfaLayoutComplete", highlightFields);

            $('#toolbarhighlight').on('click', function () {
                xfalib.globals.highlight = !xfalib.globals.highlight;
                highlightFields();
            });
        };
        //Bug#3605558: iPad doesn't give the width values instantaneously, hence putting a time out since we need
        // width of the pages rendered.
        setTimeout(function () {
            if (!xfalib.runtime.xfa)  //Bug#3670373: In IE, doc.ready is called too early for some forms, so xfalib.runtime.xfa is undefined
                $(window).one('xfaFirstPgLayoutComplete', toolBarInit);
            else
                toolBarInit();
        }, 100);


    });
})($);


/* ========================================================================
 * Bootstrap: modal.js v3.4.1
 * https://getbootstrap.com/docs/3.4/javascript/#modals
 * ========================================================================
 * Copyright 2011-2019 Twitter, Inc.
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 * ======================================================================== */


(function ($) {
    'use strict';

    // MODAL CLASS DEFINITION
    // ======================

    var Modal = function (element, options) {
        this.options = options
        this.$body = $(document.body)
        this.$element = $(element)
        this.$dialog = this.$element.find('.modal-dialog')
        this.$backdrop = null
        this.isShown = null
        this.originalBodyPad = null
        this.scrollbarWidth = 0
        this.ignoreBackdropClick = false
        this.fixedContent = '.navbar-fixed-top, .navbar-fixed-bottom'

        if (this.options.remote) {
            this.$element
                .find('.modal-content')
                .load(this.options.remote, $.proxy(function () {
                    this.$element.trigger('loaded.bs.modal')
                }, this))
        }
    }

    Modal.VERSION = '3.4.1'

    Modal.TRANSITION_DURATION = 300
    Modal.BACKDROP_TRANSITION_DURATION = 150

    Modal.DEFAULTS = {
        backdrop: true,
        keyboard: true,
        show: true
    }

    Modal.prototype.toggle = function (_relatedTarget) {
        return this.isShown ? this.hide() : this.show(_relatedTarget)
    }

    Modal.prototype.show = function (_relatedTarget) {
        var that = this
        var e = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })

        this.$element.trigger(e)

        if (this.isShown || e.isDefaultPrevented()) return

        this.isShown = true

        this.checkScrollbar()
        this.setScrollbar()
        this.$body.addClass('modal-open')

        this.escape()
        this.resize()

        this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))

        this.$dialog.on('mousedown.dismiss.bs.modal', function () {
            that.$element.one('mouseup.dismiss.bs.modal', function (e) {
                if ($(e.target).is(that.$element)) that.ignoreBackdropClick = true
            })
        })

        this.backdrop(function () {
            var transition = $.support.transition && that.$element.hasClass('fade')

            if (!that.$element.parent().length) {
                that.$element.appendTo(that.$body) // don't move modals dom position
            }

            that.$element
                .show()
                .scrollTop(0)

            that.adjustDialog()

            if (transition) {
                that.$element[0].offsetWidth // force reflow
            }

            that.$element.addClass('in')

            that.enforceFocus()

            var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })

            transition ?
                that.$dialog // wait for modal to slide in
                    .one('bsTransitionEnd', function () {
                        that.$element.trigger('focus').trigger(e)
                    })
                    .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
                that.$element.trigger('focus').trigger(e)
        })
    }

    Modal.prototype.hide = function (e) {
        if (e) e.preventDefault()

        e = $.Event('hide.bs.modal')

        this.$element.trigger(e)

        if (!this.isShown || e.isDefaultPrevented()) return

        this.isShown = false

        this.escape()
        this.resize()

        $(document).off('focusin.bs.modal')

        this.$element
            .removeClass('in')
            .off('click.dismiss.bs.modal')
            .off('mouseup.dismiss.bs.modal')

        this.$dialog.off('mousedown.dismiss.bs.modal')

        $.support.transition && this.$element.hasClass('fade') ?
            this.$element
                .one('bsTransitionEnd', $.proxy(this.hideModal, this))
                .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
            this.hideModal()
    }

    Modal.prototype.enforceFocus = function () {
        $(document)
            .off('focusin.bs.modal') // guard against infinite focus loop
            .on('focusin.bs.modal', $.proxy(function (e) {
                if (document !== e.target &&
                    this.$element[0] !== e.target &&
                    !this.$element.has(e.target).length) {
                    this.$element.trigger('focus')
                }
            }, this))
    }

    Modal.prototype.escape = function () {
        if (this.isShown && this.options.keyboard) {
            this.$element.on('keydown.dismiss.bs.modal', $.proxy(function (e) {
                e.which == 27 && this.hide()
            }, this))
        } else if (!this.isShown) {
            this.$element.off('keydown.dismiss.bs.modal')
        }
    }

    Modal.prototype.resize = function () {
        if (this.isShown) {
            $(window).on('resize.bs.modal', $.proxy(this.handleUpdate, this))
        } else {
            $(window).off('resize.bs.modal')
        }
    }

    Modal.prototype.hideModal = function () {
        var that = this
        this.$element.hide()
        this.backdrop(function () {
            that.$body.removeClass('modal-open')
            that.resetAdjustments()
            that.resetScrollbar()
            that.$element.trigger('hidden.bs.modal')
        })
    }

    Modal.prototype.removeBackdrop = function () {
        this.$backdrop && this.$backdrop.remove()
        this.$backdrop = null
    }

    Modal.prototype.backdrop = function (callback) {
        var that = this
        var animate = this.$element.hasClass('fade') ? 'fade' : ''

        if (this.isShown && this.options.backdrop) {
            var doAnimate = $.support.transition && animate

            this.$backdrop = $(document.createElement('div'))
                .addClass('modal-backdrop ' + animate)
                .appendTo(this.$body)

            this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
                if (this.ignoreBackdropClick) {
                    this.ignoreBackdropClick = false
                    return
                }
                if (e.target !== e.currentTarget) return
                this.options.backdrop == 'static'
                    ? this.$element[0].focus()
                    : this.hide()
            }, this))

            if (doAnimate) this.$backdrop[0].offsetWidth // force reflow

            this.$backdrop.addClass('in')

            if (!callback) return

            doAnimate ?
                this.$backdrop
                    .one('bsTransitionEnd', callback)
                    .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
                callback()

        } else if (!this.isShown && this.$backdrop) {
            this.$backdrop.removeClass('in')

            var callbackRemove = function () {
                that.removeBackdrop()
                callback && callback()
            }
            $.support.transition && this.$element.hasClass('fade') ?
                this.$backdrop
                    .one('bsTransitionEnd', callbackRemove)
                    .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
                callbackRemove()

        } else if (callback) {
            callback()
        }
    }

    // these following methods are used to handle overflowing modals

    Modal.prototype.handleUpdate = function () {
        this.adjustDialog()
    }

    Modal.prototype.adjustDialog = function () {
        var modalIsOverflowing = this.$element[0].scrollHeight > document.documentElement.clientHeight

        this.$element.css({
            paddingLeft: !this.bodyIsOverflowing && modalIsOverflowing ? this.scrollbarWidth : '',
            paddingRight: this.bodyIsOverflowing && !modalIsOverflowing ? this.scrollbarWidth : ''
        })
    }

    Modal.prototype.resetAdjustments = function () {
        this.$element.css({
            paddingLeft: '',
            paddingRight: ''
        })
    }

    Modal.prototype.checkScrollbar = function () {
        var fullWindowWidth = window.innerWidth
        if (!fullWindowWidth) { // workaround for missing window.innerWidth in IE8
            var documentElementRect = document.documentElement.getBoundingClientRect()
            fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left)
        }
        this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth
        this.scrollbarWidth = this.measureScrollbar()
    }

    Modal.prototype.setScrollbar = function () {
        var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)
        this.originalBodyPad = document.body.style.paddingRight || ''
        var scrollbarWidth = this.scrollbarWidth
        if (this.bodyIsOverflowing) {
            this.$body.css('padding-right', bodyPad + scrollbarWidth)
            $(this.fixedContent).each(function (index, element) {
                var actualPadding = element.style.paddingRight
                var calculatedPadding = $(element).css('padding-right')
                $(element)
                    .data('padding-right', actualPadding)
                    .css('padding-right', parseFloat(calculatedPadding) + scrollbarWidth + 'px')
            })
        }
    }

    Modal.prototype.resetScrollbar = function () {
        this.$body.css('padding-right', this.originalBodyPad)
        $(this.fixedContent).each(function (index, element) {
            var padding = $(element).data('padding-right')
            $(element).removeData('padding-right')
            element.style.paddingRight = padding ? padding : ''
        })
    }

    Modal.prototype.measureScrollbar = function () { // thx walsh
        var scrollDiv = document.createElement('div')
        scrollDiv.className = 'modal-scrollbar-measure'
        this.$body.append(scrollDiv)
        var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
        this.$body[0].removeChild(scrollDiv)
        return scrollbarWidth
    }


    // MODAL PLUGIN DEFINITION
    // =======================

    function Plugin(option, _relatedTarget) {
        return this.each(function () {
            var $this = $(this)
            var data = $this.data('bs.modal')
            var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)

            if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
            if (typeof option == 'string') data[option](_relatedTarget)
            else if (options.show) data.show(_relatedTarget)
        })
    }

    var old = $.fn.modal

    $.fn.modal = Plugin
    $.fn.modal.Constructor = Modal


    // MODAL NO CONFLICT
    // =================

    $.fn.modal.noConflict = function () {
        $.fn.modal = old
        return this
    }


    // MODAL DATA-API
    // ==============

    $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
        var $this = $(this)
        var href = $this.attr('href')
        var target = $this.attr('data-target') ||
            (href && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7

        var $target = $(document).find(target)
        var option = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())

        if ($this.is('a')) e.preventDefault()

        $target.one('show.bs.modal', function (showEvent) {
            if (showEvent.isDefaultPrevented()) return // only register focus restorer if modal will actually get shown
            $target.one('hidden.bs.modal', function () {
                $this.is(':visible') && $this.trigger('focus')
            })
        })
        Plugin.call($target, option, this)
    })

})($);

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/


$(function ($) {
    // $doc.ready for jquery 1.8 causing issues for IE so
    // doing widget initialization on connect
 window.formBridge.connect(function () {
     var method = {
         init: function () {
             var $plugFileWidgetDom = $('[data-filewidget="true"]'),
                 options,
                 $fileWidget,
                 $inputWidget,
                 $buttonWidget,
                 $listWidget,
                 widgetName,
                 multiSelect = true,
                 optionsToWidget;
                 options = $plugFileWidgetDom.data("options") || {};
                 options.buttonText = options.buttonText || "Attach";
                 options.accept = options.accept || "audio/*, video/*, image/*, text/*, application/pdf";
                 $fileWidget = $("<div></div>").addClass("guideFieldWidget").addClass("fileUpload").attr("style","")
                                               .attr("title", xfalib.locale.Strings["Attach"]);

                 $inputWidget = $("<input/>").attr("id", "fileUpload_widget").attr("name", "fileUpload")
                     .attr("type","file")
                     .attr("style", "")
                     .attr("accept",options.accept)
                     .attr("tabindex", "-1")
                     .attr("capture","");

                 $buttonWidget = $("<button></button>").addClass("button-default").addClass("button-medium")
                     .addClass("guide-fu-attach-button")
                     .attr("type", "file")
                     .html(options.buttonText);

                 $listWidget= $('<ul></ul>').addClass("guide-fu-fileItemList");
                 $fileWidget.append($inputWidget).append($buttonWidget).append($listWidget);
                 $fileWidget.appendTo($plugFileWidgetDom);
                 widgetName = options.widgetName || "fileUpload";
                 // multiSelect is expected to be boolean by widget
                 // And the profile node passes it as string
                 // and widget.jsp passes the same as boolean
                 //  options.multiSelect can be "true" ,  "false"
                 // or can be true ,  false
                 // or it can be undefined (when initializing  multiSelect  to true defines default behaviour )
                 if(_.isBoolean(options.multiSelect)) {
                     multiSelect = options.multiSelect;
                 } else if (_.isString(options.multiSelect)) {
                     multiSelect = options.multiSelect.toLowerCase() === 'true';
                 }
                 optionsToWidget =   {
                     buttonText  : options.buttonText || "Attach",
                     multiSelect :  multiSelect,
                     fileSizeLimit : options.fileSizeLimit || "2",
                     buttonClass : options.buttonClass || "button.guide-fu-attach-button",
                     fileItemListClass : options.fileItemListClass|| "ul.guide-fu-fileItemList",
                     iframeContainer: options.iframeContainer || "body#formBody",
                     showComment :  options.showComment || false,
                     _uuidGenerator: function () { return formBridge._getUUID.apply(this); },
                     value: options.value || xfalib.runtime.fileAttachment ,
                     _filePath: options._filePath || "/tmp/fd/xfaforns",
                     widgetName: "fileUpload",
                     _getUrl: options._getUrl || formBridge._getUrl(""),
                     disablePreview: options.disablePreview || false,
                     uploaderPluginName: "adobeFileUploader"



                 };
                 var widget = $fileWidget[widgetName](optionsToWidget);
                 xfalib.runtime.fileUploadWidget = widget.data(widgetName) || widget.data("xfaWidget-" + widgetName);
             }
     };
     method.init();
 });
});



/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/

(function ($) {
    function handleScroll(event) {
        var pagingManager = window.formBridge ? window.formBridge.pagingManager() : null;
        var scrollTop = $(window).scrollTop();
        var winHeight = window.innerHeight ? window.innerHeight : $(window).height();
        var winBtmPos = scrollTop + winHeight;
        var $bodyEl = $("#formBody");
        /*We also need to take bodyScaleFactor into account in order to compare it with window height.*/
        var bodyBottom = $bodyEl.height() * xfalib.ut.XfaUtil.prototype.formScaleFactor + $bodyEl.offset().top;
        if (bodyBottom < winBtmPos + 50) {
            if (pagingManager && pagingManager.hasMorePages()) {
                $('#loadingpage').children(":not(a.pageloadnow)").css("visibility", "visible");
                xfalib.ut.XfaUtil.prototype.clearTimeoutOnDestroy(setTimeout(renderNextPage, 5)); //workaround for IPAD to show intermediate load icon
            }
        }
    }

    function handleFooterLogic() {
        var pagingManager = window.formBridge ? window.formBridge.pagingManager() : null;
        if (pagingManager == null) return;
        if (!pagingManager.hasMorePages()) {
            $('#loadingpage').css({display: "none"});
            $(window).off("scroll.xfaview");
            $('#nomorepages').css({display: "inline-block"});
        } else if (pagingManager.hasMorePages()) {
            $('#loadingpage').children(":not(a.pageloadnow)").css({visibility: "hidden"});
        }
    }

    function renderNextPage(initialLoad) {
        var pagingManager = window.formBridge ? window.formBridge.pagingManager() : null;
        if (!initialLoad && pagingManager) {
            pagingManager.renderNextPage();
        }
        handleFooterLogic();
        $(formBridge).trigger("xfaNextPageRendered");
    }

    window.renderNextPage = renderNextPage;
    window.handleFooterLogic = handleFooterLogic;
    window.handleScroll = handleScroll;
})($);


/**
 ADOBE CONFIDENTIAL

 Copyright 2014 Adobe Systems Incorporated
 All Rights Reserved.

 NOTICE:  All information contained herein is, and remains
 the property of Adobe Systems Incorporated and its suppliers,
 if any.  The intellectual and technical concepts contained
 herein are proprietary to Adobe Systems Incorporated and its
 suppliers and may be covered by U.S. and Foreign Patents,
 patents in process, and are protected by trade secret or copyright law.
 Dissemination of this information or reproduction of this material
 is strictly forbidden unless prior written permission is obtained
 from Adobe Systems Incorporated.
 */

(function ($) {
    window.FD = window.FD || {};
    FD.FP     = FD.FP || {};
    FD.FP.MF = FD.FP.MF || {};
    FD.FP.MF = {
        saveMFDraft : function(){
            var draftID = window.formBridge.customContextProperty("mfDraftId"),
                fileList = "",
                formPath = window.xfalib.runtime.renderContext.contentRoot.substring(6) + "/" +window.xfalib.runtime.renderContext.template,
                formName = window.xfalib.runtime.renderContext.template,
                formData =  null,
                urlForDraft = window.formBridge._getUrl(formPath) + "/jcr:content.fp.draft.json?func=saveDraft",
                profile = xfalib.runtime.customPropertyMap.profile,
                submitUrl = xfalib.runtime.customPropertyMap.submitUrl,
                instanceId = window.formBridge.customContextProperty("instanceId");

            var fileUploadPath = window.formBridge._getUrl(formPath) + "/jcr:content.fp.attach.jsp/" + draftID,
                showDraftStatus = function(message,id){
                                      $("#"+id).text(message).show().fadeOut(1600,"linear");
                                  };

            var obj = {
                "success":function(result){
                    window.formBridge.trigger(
                        "saveStarted",
                        window.xfalib.script.XfaModelEvent.createEvent ("saveStarted")
                    );
                    formData = result.data;
                    var data = {
                        'formName'  : formName,
                        'formPath'  : formPath,
                        'formData'  : formData,
                        'draftID'   : draftID,
                        'formType'  : "mf",
                        '_charset_' : "UTF-8",
                        'profile'   : profile,
                        'submitUrl' : submitUrl,
                        'fileList'  : fileList
                    },
                    allowedMetadata = [];

                    if(instanceId){
                        data["instanceId"] = instanceId;
                    }
                    for(key in data){
                        if(key !== 'formData') {
                            allowedMetadata.push(key);
                        }
                    }
                    data["fpAllowedMetadata"] = allowedMetadata.toString();
                    $.ajax({
                        type:"POST",
                        url: urlForDraft,
                        async: true,
                        cache: false,
                        data: data,
                        success: function (result) {
							if(result && result.draftID){
								window.formBridge.trigger(
									"saveCompleted",
									window.xfalib.script.XfaModelEvent.createEvent ("saveCompleted")
								);
								showDraftStatus(xfalib.locale.Strings.SavedSuccessfully, "fpDraftStatus");
								window.formBridge.customContextProperty("mfDraftId",result.draftID);
							} else {
							    showDraftStatus(xfalib.locale.Strings.UnableToSave,"fpDraftStatus");
							}
                        },
                        error : function (result) {
                            showDraftStatus(xfalib.locale.Strings.UnableToSave,"fpDraftStatus");
                        }
                    });
                },
                "error":function(result){
                    showDraftStatus(xfalib.locale.Strings.UnableToSave,"fpDraftStatus");
                }
            };
            var fileUploadObj = {
                "success":function(result){
                    $.each(result, function(index, res) {
                        fileList += res.path + "\n";
                    });
                    //to remove last '\n' from list
                    fileList = fileList.replace(/\n$/, "");
                    window.formBridge.getDataXML(obj);
                },
                "error":function(result){

                },
                "fileUploadPath":fileUploadPath
            };
            window.formBridge.getFileAttachmentsInfo(fileUploadObj);
        },

        _saveMFDraftWrapper: function () {
            if (typeof window.formBridge.customContextProperty("mfDraftId") === "undefined" || window.formBridge.customContextProperty("mfDraftId") == null) {
                $.ajax({
                    method: "GET",
                    url: Granite.HTTP.externalize("/content/forms/portal/draftandsubmission.fp.draft.json?func=getUid"),
                    cache : false,
                    dataType: "json"
                }).done(function (response) {
                    var draftID = response.id;
                    window.formBridge.customContextProperty("mfDraftId", draftID + "_mf");
                    FD.FP.MF.saveMFDraft();
                }).fail(function (errorObj) {
                    $("#fpDraftStatus").text(xfalib.locale.Strings.UnableToSave).show().fadeOut(1600,"linear");
                    return 0;
                });
            } else {
                FD.FP.MF.saveMFDraft();
            }
        }
    };

    $(document).ready(function(){
        $("#toolbarsavebtn").click(function(){
            window.FD.FP.MF._saveMFDraftWrapper();
        })
    });
})(jQuery);
/*************************************************************************
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 * Copyright 2023 Adobe
 * All Rights Reserved.
 *
 * NOTICE: All information contained herein is, and remains
 * the property of Adobe and its suppliers, if any. The intellectual
 * and technical concepts contained herein are proprietary to Adobe
 * and its suppliers and are protected by all applicable intellectual
 * property laws, including trade secret and copyright laws.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe.
 **************************************************************************/

(function ($) {
	window.FD = window.FD || {}
	var toggles;

	var httpEval = function (url) {
		var response = $.ajax({
			url: url,
			type: "get",
			async: false,
			dataType: "json"
		});
		if(response.status!=200){
           return;
        }
		var text = response.body ? response.body : response.responseText;
		return JSON.parse(text);
	};


	FD.isToggleEnabled = function (toggleName) {
		var contextRoot = (typeof formBridge !== 'undefined' && formBridge._getContextRoot()) ? formBridge._getContextRoot() :
			(typeof guideBridge !== 'undefined' && guideBridge._getContextRoot()) ? guideBridge._getContextRoot() : "";
		toggles = toggles || httpEval(contextRoot + "/etc.clientlibs/toggles.json");
		var retVal = false;
		if (toggles && toggles.enabled instanceof Array) {
			retVal = toggles.enabled.indexOf(toggleName) > -1
		}
		return retVal;
	}
})(jQuery);


/*******************************************************************************
 * ADOBE CONFIDENTIAL
 *  ___________________
 *
 *   Copyright 2013 Adobe Systems Incorporated
 *   All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains
 *  the property of Adobe Systems Incorporated and its suppliers,
 *  if any.  The intellectual and technical concepts contained
 *  herein are proprietary to Adobe Systems Incorporated and its
 *  suppliers and are protected by all applicable intellectual property
 *  laws, including trade secret and copyright laws.
 *  Dissemination of this information or reproduction of this material
 *  is strictly forbidden unless prior written permission is obtained
 *  from Adobe Systems Incorporated.
 ******************************************************************************/
(function($){
    window.formBridge.connect(
        function(){
            var titleResult = window.formBridge.getFieldProperties("xfa.form..desc.title","value");
            if(titleResult && !titleResult.errors && titleResult.data && titleResult.data[0]){
                $(document).attr('title', titleResult.data[0]);
            }
        }
    );
})($);


/*
 * ADOBE CONFIDENTIAL
 *
 * Copyright 2016 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 */

window.jQuery.noConflict(true);
if (!window.jQuery) {
    window.jQuery = window.xfalib.jQuery;
}
if (!window.$) {
    window.$ = window.xfalib.$;
}

window._.noConflict();
if (!window._) {
    window._ = window.xfalib._;
}
", "headers" : { "X-Content-Type-Options" : "nosniff", - "Last-Modified" : "Sat, 03 May 2025 13:59:40 GMT", - "Date" : "Sun, 11 May 2025 11:23:44 GMT", + "Last-Modified" : "Thu, 18 Sep 2025 12:51:51 GMT", + "Date" : "Sun, 16 Nov 2025 14:26:31 GMT", "Content-Type" : "application/javascript;charset=utf-8" } }, - "uuid" : "0d679342-fffe-4666-9286-bd35cc64a58e", + "uuid" : "0a024c8e-aa5e-4459-91bf-531695e412fe", "persistent" : true, - "insertionIndex" : 19 + "insertionIndex" : 33 } \ No newline at end of file diff --git a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_toggles_json.json b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_toggles_json.json index 8d950c94..b645c37d 100644 --- a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_toggles_json.json +++ b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_etc.clientlibs_toggles_json.json @@ -1,5 +1,5 @@ { - "id" : "12f8a3d2-2fed-45c3-a025-7f8668b43320", + "id" : "df2fc952-74e3-4262-8fad-6ed36fd6a6ad", "name" : "etc.clientlibs_toggles.json", "request" : { "url" : "/etc.clientlibs/toggles.json", @@ -10,11 +10,11 @@ "body" : "{\"enabled\":[\"ENABLED\"]}", "headers" : { "Cache-Control" : "max-age=30", - "Date" : "Sun, 11 May 2025 11:23:47 GMT", + "Date" : "Sun, 16 Nov 2025 14:26:33 GMT", "Content-Type" : "application/json;charset=utf-8" } }, - "uuid" : "12f8a3d2-2fed-45c3-a025-7f8668b43320", + "uuid" : "df2fc952-74e3-4262-8fad-6ed36fd6a6ad", "persistent" : true, - "insertionIndex" : 18 + "insertionIndex" : 32 } \ No newline at end of file diff --git a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_libs_granite_csrf_token_json.json b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_libs_granite_csrf_token_json.json index dfd5330a..f26ec0c1 100644 --- a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_libs_granite_csrf_token_json.json +++ b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_libs_granite_csrf_token_json.json @@ -1,22 +1,21 @@ { - "id" : "34969b80-157b-4075-8fdf-adc52fd6ce11", - "name" : "libs_granite_csrf_token.json", + "id" : "c5b7cce5-d5fc-47b5-bd75-6214d86d7e05", + "name" : "etc.clientlibs_clientlibs_granite_jquery_granite_csrf.js", "request" : { - "url" : "/libs/granite/csrf/token.json", + "url" : "/etc.clientlibs/clientlibs/granite/jquery/granite/csrf.js", "method" : "GET" }, "response" : { "status" : 200, - "body" : "{\"token\":\"eyJleHAiOjE3NDY5NjMyMjgsImlhdCI6MTc0Njk2MjYyOH0.LCykkZEZpvibCViWTKfXMVDFJ3V5aUoXVrn53xwpZWY\"}", + "base64Body" : "/*
 * ADOBE CONFIDENTIAL
 *
 * Copyright 2015 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 *
 */
/* global CQURLInfo:false */
(function(window) {
    "use strict";

    window.Granite = window.Granite || {};
    window.Granite.HTTP = window.Granite.HTTP || {};

    var contextPath = null;

    function detectContextPath() {
        // eslint-disable-next-line max-len
        var SCRIPT_URL_REGEXP = /^(?:http|https):\/\/[^/]+(\/.*)\/(?:etc\.clientlibs|etc(\/.*)*\/clientlibs|libs(\/.*)*\/clientlibs|apps(\/.*)*\/clientlibs|etc\/designs).*\.js(\?.*)?$/;
        try {
            if (window.CQURLInfo) {
                contextPath = CQURLInfo.contextPath || "";
            } else {
                var scripts = document.getElementsByTagName("script");
                for (var i = 0; i < scripts.length; i++) {
                    var result = SCRIPT_URL_REGEXP.exec(scripts[i].src);
                    if (result) {
                        contextPath = result[1];
                        return;
                    }
                }
                contextPath = "";
            }
        } catch (e) {
            // ignored
        }
    }

    window.Granite.HTTP.externalize = window.Granite.HTTP.externalize || function(url) {
        if (contextPath === null) {
            detectContextPath();
        }

        try {
            if (url.indexOf("/") === 0 && contextPath && url.indexOf(contextPath + "/") !== 0) {
                url = contextPath + url;
            }
        } catch (e) {
            // ignored
        }

        return url;
    };
})(this);

/*
 * ADOBE CONFIDENTIAL
 *
 * Copyright 2015 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 *
 */
(function(factory) {
    "use strict";

    // GRANITE-22281 Check for multiple initialization
    if (window.Granite.csrf) {
        return;
    }

    window.Granite.csrf = factory(window.Granite.HTTP);
}(function(http) {
    "use strict";

    // AdobePatentID="P5296"

    function Promise() {
        this._handler = [];
    }

    Promise.prototype = {
        then: function(resolveFn, rejectFn) {
            this._handler.push({ resolve: resolveFn, reject: rejectFn });
        },
        resolve: function() {
            this._execute("resolve", arguments);
        },
        reject: function() {
            this._execute("reject", arguments);
        },
        _execute: function(result, args) {
            if (this._handler === null) {
                throw new Error("Promise already completed.");
            }

            for (var i = 0, ln = this._handler.length; i < ln; i++) {
                this._handler[i][result].apply(window, args);
            }

            this.then = function(resolveFn, rejectFn) {
                (result === "resolve" ? resolveFn : rejectFn).apply(window, args);
            };

            this._handler = null;
        }
    };

    function verifySameOrigin(url) {
        // url could be relative or scheme relative or absolute
        // host + port
        var host = document.location.host;
        var protocol = document.location.protocol;
        var relativeOrigin = "//" + host;
        var origin = protocol + relativeOrigin;

        // Allow absolute or scheme relative URLs to same origin
        return (url === origin || url.slice(0, origin.length + 1) === origin + "/") ||
                (url === relativeOrigin || url.slice(0, relativeOrigin.length + 1) === relativeOrigin + "/") ||
                // or any other URL that isn't scheme relative or absolute i.e relative.
                !(/^(\/\/|http:|https:).*/.test(url));
    }

    var FIELD_NAME = ":cq_csrf_token";
    var HEADER_NAME = "CSRF-Token";
    var TOKEN_SERVLET = http.externalize("/libs/granite/csrf/token.json");

    var promise;
    var globalToken;

    function logFailRequest(error) {
        if (window.console) {
            // eslint-disable-next-line no-console
            console.warn("CSRF data not available;" +
                    "The data may be unavailable by design, such as during non-authenticated requests: " + error);
        }
    }

    function getToken() {
        var localPromise = new Promise();
        promise = localPromise;

        var xhr = new XMLHttpRequest();
        xhr.onreadystatechange = function() {
            if (xhr.readyState === 4) {
                try {
                    var data = JSON.parse(xhr.responseText);
                    globalToken = data.token;
                    localPromise.resolve(globalToken);
                } catch (ex) {
                    logFailRequest(ex);
                    localPromise.reject(xhr.responseText);
                }
            }
        };
        xhr.open("GET", TOKEN_SERVLET, true);
        xhr.send();

        return localPromise;
    }

    function getTokenSync() {
        var xhr = new XMLHttpRequest();
        xhr.open("GET", TOKEN_SERVLET, false);
        xhr.send();

        try {
            return globalToken = JSON.parse(xhr.responseText).token;
        } catch (ex) {
            logFailRequest(ex);
        }
    }

    function clearToken() {
        globalToken = undefined;
        getToken();
    }

    function addField(form) {
        var action = form.getAttribute("action");
        if (form.method.toUpperCase() === "GET" || (action && !verifySameOrigin(action))) {
            return;
        }

        if (!globalToken) {
            getTokenSync();
        }

        if (!globalToken) {
            return;
        }

        var input = form.querySelector('input[name="' + FIELD_NAME + '"]');

        if (!input) {
            input = document.createElement("input");
            input.setAttribute("type", "hidden");
            input.setAttribute("name", FIELD_NAME);
            form.appendChild(input);
        }

        input.setAttribute("value", globalToken);
    }

    function handleForm(document) {
        var handler = function(ev) {
            var t = ev.target;

            if (t.nodeName === "FORM") {
                addField(t);
            }
        };

        if (document.addEventListener) {
            document.addEventListener("submit", handler, true);
        } else if (document.attachEvent) {
            document.attachEvent("submit", handler);
        }
    }

    handleForm(document);

    var open = XMLHttpRequest.prototype.open;

    XMLHttpRequest.prototype.open = function(method, url, async) {
        if (method.toLowerCase() !== "get" && verifySameOrigin(url)) {
            this._csrf = true;
            this._async = async;
        }

        return open.apply(this, arguments);
    };

    var send = XMLHttpRequest.prototype.send;

    XMLHttpRequest.prototype.send = function() {
        if (!this._csrf) {
            send.apply(this, arguments);
            return;
        }

        if (globalToken) {
            this.setRequestHeader(HEADER_NAME, globalToken);
            send.apply(this, arguments);
            return;
        }

        if (this._async === false) {
            getTokenSync();

            if (globalToken) {
                this.setRequestHeader(HEADER_NAME, globalToken);
            }

            send.apply(this, arguments);
            return;
        }

        var self = this;
        var args = Array.prototype.slice.call(arguments);

        promise.then(function(token) {
            self.setRequestHeader(HEADER_NAME, token);
            send.apply(self, args);
        }, function() {
            send.apply(self, args);
        });
    };

    var submit = HTMLFormElement.prototype.submit;

    HTMLFormElement.prototype.submit = function() {
        addField(this);
        return submit.apply(this, arguments);
    };

    if (window.Node) {
        var ac = Node.prototype.appendChild;

        Node.prototype.appendChild = function() {
            var result = ac.apply(this, arguments);

            if (result.nodeName === "IFRAME") {
                try {
                    if (result.contentWindow && !result._csrf) {
                        result._csrf = true;
                        handleForm(result.contentWindow.document);
                    }
                } catch (ex) {
                    if (result.src && result.src.length && verifySameOrigin(result.src)) {
                        if (window.console) {
                            // eslint-disable-next-line no-console
                            console.error("Unable to attach CSRF token to an iframe element on the same origin");
                        }
                    }

                    // Potential error: Access is Denied
                    // we can safely ignore CORS security errors here
                    // because we do not want to expose the csrf anyways to another domain
                }
            }

            return result;
        };
    }

    // refreshing csrf token periodically
    getToken();

    setInterval(function() {
        getToken();
    }, 300000);

    return {
        initialised: false,
        refreshToken: getToken,
        _clearToken: clearToken
    };
}));

", "headers" : { - "Cache-Control" : "no-cache", "X-Content-Type-Options" : "nosniff", - "Expires" : "-1", - "Date" : "Sun, 11 May 2025 11:23:48 GMT", - "Content-Type" : "application/json" + "Last-Modified" : "Thu, 18 Sep 2025 12:46:42 GMT", + "Date" : "Sun, 16 Nov 2025 14:26:31 GMT", + "Content-Type" : "application/javascript;charset=utf-8" } }, - "uuid" : "34969b80-157b-4075-8fdf-adc52fd6ce11", + "uuid" : "c5b7cce5-d5fc-47b5-bd75-6214d86d7e05", "persistent" : true, - "insertionIndex" : 17 + "insertionIndex" : 34 } \ No newline at end of file diff --git a/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_services_html5_renderhtml5form.json b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_services_html5_renderhtml5form.json new file mode 100644 index 00000000..bc23abdc --- /dev/null +++ b/spring/fluentforms-sample-webmvc-app/src/test/resources/mappings/AemProxyEndpointTest_proxyTest_services_html5_renderhtml5form.json @@ -0,0 +1,25 @@ +{ + "id" : "dd236fa1-e635-4d56-a090-b9e6b99a5955", + "name" : "services_html5_renderhtml5form", + "request" : { + "url" : "/services/Html5/RenderHtml5Form", + "method" : "POST", + "bodyPatterns" : [ { + "anything" : "anything" + } ] + }, + "response" : { + "status" : 200, + "body" : "\n\n\n\n\n\n \n \n\n\n\n\n\n\nLC Forms\n\n\n\n\n\n\n\n\n \n \n
\n
Loading
\n
\n \n \n\n\n\n\n
\n Please fill the following form.\n \n \n\n \n \n
\n\n \n\n\n\n\n\n\n\n\n \n \n \n\n\n\n\n \n\n\n\n \n \n\n\n\n\n\n\n
\n
\n

Loading...

\n \n
\n
\n\n\n\n\n \n \n\n
\n
\n
\n \n Loading...\n --Load now--\n
\n
\n --No more pages--\n
\n
\n
\n\n\n\n\n \n\n\n \n \n\n\n\n\n\n\n
\n
\n
\n
\n

Attachments

\n
\n
\n
\n\n
\n
\n \n
\n
\n \n
\n
\n
\n \n
\n \n
\n\n\n\n\n \n\n", + "headers" : { + "X-Content-Type-Options" : "nosniff", + "Set-Cookie" : "cq-authoring-mode=TOUCH; Path=/; Expires=Sun, 23-Nov-2025 14:26:29 GMT; Max-Age=604800", + "Expires" : "Thu, 01 Jan 1970 00:00:00 GMT", + "Date" : "Sun, 16 Nov 2025 14:26:29 GMT", + "Content-Type" : "text/html;charset=utf-8" + } + }, + "uuid" : "dd236fa1-e635-4d56-a090-b9e6b99a5955", + "persistent" : true, + "insertionIndex" : 37 +} \ No newline at end of file diff --git a/spring/fluentforms-spring-boot-autoconfigure/pom.xml b/spring/fluentforms-spring-boot-autoconfigure/pom.xml index c942c402..35838067 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/pom.xml +++ b/spring/fluentforms-spring-boot-autoconfigure/pom.xml @@ -5,13 +5,13 @@ org.springframework.boot spring-boot-starter-parent - 3.5.5 + 3.5.7 com._4point.aem.fluentforms fluentforms-spring-boot-autoconfigure 0.0.5-SNAPSHOT - AutoConfigure Project + FluentForms AutoConfigure Project 17 @@ -19,7 +19,7 @@ 3.0.5 0.0.5-SNAPSHOT 0.0.4-SNAPSHOT - 4.0.0-beta.15 + 4.0.0-beta.16 1.20.2 1.2.3 @@ -66,7 +66,7 @@ org.springframework.boot - spring-boot-starter-jersey + spring-boot-starter-web true provided @@ -80,11 +80,6 @@ rest-services.client ${fluentforms.version} - - com._4point.aem.docservices.rest-services - rest-services.jersey-client - ${fluentforms.version} - org.springframework.boot diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemConfiguration.java b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemConfiguration.java index f8a6615b..ee55d261 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemConfiguration.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemConfiguration.java @@ -27,6 +27,6 @@ public record AemConfiguration( ) { public String url() { - return "http" + (useSsl ? "s" : "") + "://" + servername + (port != 80 ? ":" + port : "") + "/"; + return "http" + (useSsl ? "s" : "") + "://" + servername + (port != null && port != 80 ? ":" + port : "") + "/"; } } diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmission.java b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmission.java index 7fce01ed..3e0a4e65 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmission.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmission.java @@ -1,46 +1,41 @@ package com._4point.aem.fluentforms.spring; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; import java.io.IOException; -import java.io.InputStream; +import java.io.UncheckedIOException; import java.net.URI; import java.nio.charset.StandardCharsets; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import java.util.Objects; import java.util.Optional; +import java.util.function.Consumer; import java.util.function.Function; import java.util.regex.Pattern; -import org.glassfish.jersey.client.ChunkedInput; -import org.glassfish.jersey.client.ClientProperties; -import org.glassfish.jersey.media.multipart.BodyPartEntity; -import org.glassfish.jersey.media.multipart.FormDataBodyPart; -import org.glassfish.jersey.media.multipart.FormDataMultiPart; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.ssl.SslBundles; +import org.springframework.boot.autoconfigure.web.client.RestClientSsl; +import org.springframework.boot.ssl.NoSuchSslBundleException; +import org.springframework.context.annotation.Lazy; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.HttpStatusCode; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.http.client.ClientHttpRequestInterceptor; +import org.springframework.http.client.support.BasicAuthenticationInterceptor; import org.springframework.util.MultiValueMap; import org.springframework.util.MultiValueMapAdapter; - -import jakarta.ws.rs.Consumes; -import jakarta.ws.rs.InternalServerErrorException; -import jakarta.ws.rs.POST; -import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; -import jakarta.ws.rs.Produces; -import jakarta.ws.rs.client.Client; -import jakarta.ws.rs.client.Entity; -import jakarta.ws.rs.client.WebTarget; -import jakarta.ws.rs.core.Context; -import jakarta.ws.rs.core.GenericType; -import jakarta.ws.rs.core.HttpHeaders; -import jakarta.ws.rs.core.MediaType; -import jakarta.ws.rs.core.MultivaluedMap; -import jakarta.ws.rs.core.Response; +import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.client.RestClient; +import org.springframework.web.multipart.MultipartHttpServletRequest; +import org.springframework.web.util.UriBuilder; /** * Class that handles Adaptive Form Submissions. @@ -60,27 +55,30 @@ * * */ -@Path("/aem") +@Lazy // Not sure why this is required, but without it the Jersey auto-configuration tests fail. Leaving it in for now. +@CrossOrigin +@RestController +@RequestMapping("/aem") public class AemProxyAfSubmission { private final static Logger logger = LoggerFactory.getLogger(AemProxyAfSubmission.class); - private static final String CONTENT_FORMS_AF = "content/forms/af/"; + private static final String CONTENT_FORMS_AF = "/content/forms/af/"; + + private final SpringAfSubmitProcessor submitProcessor; - @Autowired - AfSubmitProcessor submitProcessor; + AemProxyAfSubmission(SpringAfSubmitProcessor submitProcessor) { + this.submitProcessor = submitProcessor; + } - @Path(CONTENT_FORMS_AF + "{remainder : .+}") - @POST - @Consumes(MediaType.MULTIPART_FORM_DATA) - @Produces(MediaType.WILDCARD) - public Response proxySubmitPost(@PathParam("remainder") String remainder, /* @HeaderParam(CorrelationId.CORRELATION_ID_HDR) final String correlationIdHdr,*/ @Context HttpHeaders headers, final FormDataMultiPart inFormData) { + @PostMapping(path = CONTENT_FORMS_AF + "{*remainder}", consumes = MediaType.MULTIPART_FORM_DATA_VALUE, produces = MediaType.ALL_VALUE) + public ResponseEntity proxySubmitPost(@PathVariable("remainder") String remainder, /* @HeaderParam(CorrelationId.CORRELATION_ID_HDR) final String correlationIdHdr,*/ @RequestHeader HttpHeaders headers, final MultipartHttpServletRequest inFormData) { logger.atInfo().addArgument(()->submitProcessor != null ? submitProcessor.getClass().getName() : "null" ).log("Submit proxy called. SubmitProcessor={}"); // final String correlationId = CorrelationId.generate(correlationIdHdr); // ProcessingMetadataBuilder pmBuilder = ProcessingMetadata.start(correlationId); - return submitProcessor.processRequest(inFormData, headers, remainder); + return submitProcessor.processRequest(inFormData, remainder); } /** - * Transforms a FormDataMultiPart object using a set of provided functions. + * Transforms a incoming object using a set of provided functions. * * Accepts incoming form data, in the form of a FormDataMultiPart object and a Map collection of functions. It walks through the * parts and if it finds a function in the Map with the same name it executes that function on the the data from the corresponding part. @@ -92,29 +90,21 @@ public Response proxySubmitPost(@PathParam("remainder") String remainder, /* @He * @return * @throws IOException */ - private static FormDataMultiPart transformFormData(final FormDataMultiPart inFormData, final Map> fieldFunctions, Logger logger) { - try { - FormDataMultiPart outFormData = new FormDataMultiPart(); - var fields = inFormData.getFields(); - logger.atDebug().log(()->"Found " + fields.size() + " fields"); - - for (var fieldEntry : fields.entrySet()) { - String fieldName = fieldEntry.getKey(); - for (FormDataBodyPart fieldData : fieldEntry.getValue()) { - logger.atDebug().log(()->"Copying '" + fieldName + "' field"); - byte[] fieldBytes = ((BodyPartEntity)fieldData.getEntity()).getInputStream().readAllBytes(); - logger.atTrace().log(()->"Fieldname '" + fieldName + "' is '" + new String(fieldBytes) + "'."); - var fieldFn = fieldFunctions.getOrDefault(fieldName, Function.identity()); // Look for an entry in fieldFunctions table for this field. Return the Identity function if we don't find one. - byte[] modifiedFieldBytes = fieldFn.apply(fieldBytes); - if (modifiedFieldBytes != null) { // If the function returned bytes (if not, then remove that part) - outFormData.field(fieldName, new String(modifiedFieldBytes, StandardCharsets.UTF_8)); // Apply the field function to bytes. - } - } + private static MultipartHttpServletRequest transformFormData(final MultipartHttpServletRequest inFormData, final Map> fieldFunctions, Logger logger) { + var fields = inFormData.getParameterMap(); + logger.atDebug().log(()->"Found " + fields.size() + " fields"); + + for (var fieldEntry : fields.entrySet()) { + String fieldName = fieldEntry.getKey(); + for (var fieldData : fieldEntry.getValue()) { + logger.atDebug().log(()->"Copying '" + fieldName + "' field"); + byte[] fieldBytes = fieldData.getBytes(); + logger.atTrace().log(()->"Fieldname '" + fieldName + "' is '" + new String(fieldBytes) + "'."); + var fieldFn = fieldFunctions.getOrDefault(fieldName, Function.identity()); // Look for an entry in fieldFunctions table for this field. Return the Identity function if we don't find one. + fieldFn.apply(fieldBytes); // throw away the result. } - return outFormData; - } catch (IOException e) { - throw new InternalServerErrorException("Error while transforming submission data.", e); } + return inFormData; } /** @@ -126,7 +116,7 @@ private static FormDataMultiPart transformFormData(final FormDataMultiPart inFor * */ @FunctionalInterface - public interface AfSubmitProcessor { + public interface SpringAfSubmitProcessor { /** * Processor to process incoming Adaptive Forms submit. * @@ -138,11 +128,11 @@ public interface AfSubmitProcessor { * Adaptive Forms location path (relative to /content/forms/af/) * @return */ - Response processRequest(final FormDataMultiPart inFormData, HttpHeaders headers, String remainder); + ResponseEntity processRequest(final MultipartHttpServletRequest inFormData, String remainder); } @FunctionalInterface - public interface AfFormDataTransformer { + public interface SpringAfFormDataTransformer { /** * If one or more of these are available in the Spring context, they will be run against the incoming * data before it is processed. @@ -158,7 +148,7 @@ public interface AfFormDataTransformer { * @return * outgoing form data object */ - FormDataMultiPart transformFormData(final FormDataMultiPart inFormData); + MultipartHttpServletRequest transformFormData(final MultipartHttpServletRequest inFormData); } /** * This processor forwards the Adaptive Form submissions on to AEM for processing by the AEM instance. @@ -169,50 +159,118 @@ public interface AfFormDataTransformer { * Spring context. * */ - static class AfSubmitAemProxyProcessor implements AfSubmitProcessor { + static class AfSubmitAemProxyProcessor implements SpringAfSubmitProcessor { - private final AemConfiguration aemConfig; - private final Client httpClient; + private final RestClient httpClient; - public AfSubmitAemProxyProcessor(AemConfiguration aemConfig, SslBundles sslBundles) { - this.aemConfig = aemConfig; - this.httpClient = JerseyClientFactory.createClient(sslBundles, aemConfig.sslBundle(), aemConfig.user(), aemConfig.password()); + public AfSubmitAemProxyProcessor(AemConfiguration aemConfig, RestClientSsl restClientSsl) { + this.httpClient = Optional.of(RestClient.builder()) + .map(b->b.baseUrl(aemConfig.url())) + .map(b->configureBasicAuthentication(b, aemConfig)) + .map(b->configureSsl(b, aemConfig, restClientSsl)) + .get().build(); +// this.httpClient = configureBasicAuthentication(RestClient.builder().baseUrl(aemConfig.url()), aemConfig).build(); +// JerseyClientFactory.createClient(sslBundles, aemConfig.sslBundle(), aemConfig.user(), aemConfig.password()); + } + + private static RestClient.Builder configureBasicAuthentication( + RestClient.Builder builder, + AemConfiguration aemConfig + ) { + ClientHttpRequestInterceptor basicAuth = new BasicAuthenticationInterceptor(aemConfig.user(), aemConfig.password()); + + return builder.requestInterceptor(basicAuth); + } + + private static RestClient.Builder configureSsl(RestClient.Builder builder, AemConfiguration aemConfig, RestClientSsl restClientSsl) { + return aemConfig.useSsl() ? builder.apply(getSslBundle(aemConfig.sslBundle(), restClientSsl)) + : builder; + } + + private static Consumer getSslBundle(String sslBundleName, RestClientSsl restClientSsl) { + try { + return restClientSsl.fromBundle(sslBundleName); + } catch (NoSuchSslBundleException e) { + // Default to normal SSL context (which includes the default trust store) + // This is not ideal since misspelling the bundle name silently fails, but is required to avoid breaking existing code. + // At dome point it should probably be changed to let the exception pass and only use the default SSL context + // if the SSL bundle name is empty. + return b->{}; // No-op; + } } @Override - public Response processRequest(FormDataMultiPart formSubmission, HttpHeaders headers, String remainder) { - logger.atTrace().addArgument(()->{ String formData = formSubmission.getField("jcr:data").getEntityAs(String.class); - return formData != null ? formData : "null"; - }) + public ResponseEntity processRequest(MultipartHttpServletRequest formSubmission, String remainder) { + logger.atTrace().addArgument(()->getFormData(formSubmission)) .log("AF Submit Proxy: Data = '{}'"); // Transfer to AEM - String contentType = headers.getMediaType().toString(); - String cookie = headers.getHeaderString("cookie"); - WebTarget webTarget = httpClient.target(aemConfig.url()) - .property(ClientProperties.FOLLOW_REDIRECTS, Boolean.FALSE) - .path("/" + CONTENT_FORMS_AF + remainder); + var headers = formSubmission.getRequestHeaders(); +// String contentType = headers.getContentType().toString(); +// String cookie = headers.getFirst("cookie"); + ResponseEntity result = httpClient.post() + .uri(ub->appendPath(ub, remainder)) + .body(new HttpEntity<>(formSubmission.getMultiFileMap(), headers)) +// .headers(h->{ +// h.set("cookie", cookie); +// }) + .retrieve() + .toEntity(byte[].class) + ; + +// WebTarget webTarget = httpClient.target(aemConfig.url()) +// .property(ClientProperties.FOLLOW_REDIRECTS, Boolean.FALSE) +// .path("/" + CONTENT_FORMS_AF + remainder); +// +// logger.atDebug().log(()->"Proxying Submit POST request for target '" + webTarget.getUri().toString() + "'."); +// Response result = webTarget.request() +// .header("cookie", cookie) +// .post(Entity.entity(formSubmission , contentType)); - logger.atDebug().log(()->"Proxying Submit POST request for target '" + webTarget.getUri().toString() + "'."); - Response result = webTarget.request() - .header("cookie", cookie) - .post(Entity.entity(formSubmission , contentType)); + logger.atDebug().log(()->"AEM Response = " + result.getStatusCode().value()); + logger.atDebug().log(()->"AEM Response Location = " + result.getHeaders().getLocation()); - logger.atDebug().log(()->"AEM Response = " + result.getStatus()); - logger.atDebug().log(()->"AEM Response Location = " + result.getLocation()); + // TODO: Add correlation ID header + return ResponseEntity.status(result.getStatusCode()) + .headers(removeChunkedTransferEncoding(result.getHeaders())) + .body(result.getBody()); +// String aemResponseEncoding = result.getHeaderString("Transfer-Encoding"); +// if (aemResponseEncoding != null && aemResponseEncoding.equalsIgnoreCase("chunked")) { +// logger.atDebug().log("Returning chunked response from AEM."); +// return Response.status(result.getStatus()).entity(new ByteArrayInputStream(transferFromAem(result, logger))) +// .type(result.getMediaType()) +//// .header(CorrelationId.CORRELATION_ID_HDR, correlationId) +// .build(); +// } else { +// logger.atDebug().log("Returning response from AEM."); +// return Response.fromResponse(result) +//// .header(CorrelationId.CORRELATION_ID_HDR, correlationId) +// .build(); +// } + } + + private HttpHeaders removeChunkedTransferEncoding(HttpHeaders headers) { + var transferEncoding = headers.getFirst(HttpHeaders.TRANSFER_ENCODING); + if (transferEncoding != null && transferEncoding.equalsIgnoreCase("chunked")) { + var newHeaders = new HttpHeaders(headers); + newHeaders.remove(HttpHeaders.TRANSFER_ENCODING); + return newHeaders; + } + return headers; + } - String aemResponseEncoding = result.getHeaderString("Transfer-Encoding"); - if (aemResponseEncoding != null && aemResponseEncoding.equalsIgnoreCase("chunked")) { - logger.atDebug().log("Returning chunked response from AEM."); - return Response.status(result.getStatus()).entity(new ByteArrayInputStream(transferFromAem(result, logger))) - .type(result.getMediaType()) -// .header(CorrelationId.CORRELATION_ID_HDR, correlationId) - .build(); - } else { - logger.atDebug().log("Returning response from AEM."); - return Response.fromResponse(result) -// .header(CorrelationId.CORRELATION_ID_HDR, correlationId) - .build(); + private static URI appendPath(UriBuilder builder, String remainder) { + var uri = builder.path(CONTENT_FORMS_AF + remainder).build(); + logger.atDebug().log(()->"Proxying Submit POST request for target '" + uri.toString() + "'."); + return uri; + } + + private static String getFormData(MultipartHttpServletRequest formSubmission) { + try { + var formData = formSubmission.getFile("jcr:data"); + return formData != null ? formData.getResource().getContentAsString(StandardCharsets.UTF_8) : "null"; + } catch (IOException e) { + throw new UncheckedIOException(e); } } @@ -224,43 +282,43 @@ public Response processRequest(FormDataMultiPart formSubmission, HttpHeaders hea * @return * @throws IOException */ - private static byte[] transferFromAem(Response result, Logger logger) { - try { - if (logger.isDebugEnabled()) { - logger.debug("AEM Response Mediatype=" + (result.getMediaType() != null ? result.getMediaType().toString(): "null")); - MultivaluedMap headers = result.getHeaders(); - for(Entry> entry : headers.entrySet()) { - String msgLine = "For header '" + entry.getKey() + "', "; - for (Object value : entry.getValue()) { - msgLine += "'" + value.toString() + "' "; - } - logger.debug(msgLine); - } - } - - String aemResponseEncoding = result.getHeaderString("Transfer-Encoding"); - if (aemResponseEncoding != null && aemResponseEncoding.equalsIgnoreCase("chunked")) { - // They've sent back chunked response. - logger.debug("Found a chunked encoding."); - final ChunkedInput chunkedInput = result.readEntity(new GenericType>() {}); - byte[] chunk; - ByteArrayOutputStream buffer = new ByteArrayOutputStream(); - try (buffer) { - while ((chunk = chunkedInput.read()) != null) { - buffer.writeBytes(chunk); - logger.debug("Read chunk from AEM response."); - } - } - - return buffer.toByteArray(); - } else { - return ((InputStream)result.getEntity()).readAllBytes(); - } - } catch (IllegalStateException | IOException e) { - throw new InternalServerErrorException("Error while processing transferring result from AEM.", e); - } - } - +// private static byte[] transferFromAem(Response result, Logger logger) { +// try { +// if (logger.isDebugEnabled()) { +// logger.debug("AEM Response Mediatype=" + (result.getMediaType() != null ? result.getMediaType().toString(): "null")); +// MultivaluedMap headers = result.getHeaders(); +// for(Entry> entry : headers.entrySet()) { +// String msgLine = "For header '" + entry.getKey() + "', "; +// for (Object value : entry.getValue()) { +// msgLine += "'" + value.toString() + "' "; +// } +// logger.debug(msgLine); +// } +// } +// +// String aemResponseEncoding = result.getHeaderString("Transfer-Encoding"); +// if (aemResponseEncoding != null && aemResponseEncoding.equalsIgnoreCase("chunked")) { +// // They've sent back chunked response. +// logger.debug("Found a chunked encoding."); +// final ChunkedInput chunkedInput = result.readEntity(new GenericType>() {}); +// byte[] chunk; +// ByteArrayOutputStream buffer = new ByteArrayOutputStream(); +// try (buffer) { +// while ((chunk = chunkedInput.read()) != null) { +// buffer.writeBytes(chunk); +// logger.debug("Read chunk from AEM response."); +// } +// } +// +// return buffer.toByteArray(); +// } else { +// return ((InputStream)result.getEntity()).readAllBytes(); +// } +// } catch (IllegalStateException | IOException e) { +// throw new InternalServerErrorException("Error while processing transferring result from AEM.", e); +// } +// } +// } /** @@ -289,7 +347,7 @@ public record Response(byte[] responseBytes, String mediaType) implements Submit * @return * Response object with a media type of "text/plain" */ - public static Response text(String text) { return new Response(text.getBytes(StandardCharsets.UTF_8), MediaType.TEXT_PLAIN); } + public static Response text(String text) { return new Response(text.getBytes(StandardCharsets.UTF_8), MediaType.TEXT_PLAIN_VALUE); } /** * Creates an HTML response from a String * @@ -298,7 +356,7 @@ public record Response(byte[] responseBytes, String mediaType) implements Submit * @return * Response object with a media type of "text/html" */ - public static Response html(String html) { return new Response(html.getBytes(StandardCharsets.UTF_8), MediaType.TEXT_HTML); } + public static Response html(String html) { return new Response(html.getBytes(StandardCharsets.UTF_8), MediaType.TEXT_HTML_VALUE); } /** * Creates an JSON response from a String * @@ -307,7 +365,7 @@ public record Response(byte[] responseBytes, String mediaType) implements Submit * @return * Response object with a media type of "application/html" */ - public static Response json(String json) { return new Response(json.getBytes(StandardCharsets.UTF_8), MediaType.APPLICATION_JSON); } + public static Response json(String json) { return new Response(json.getBytes(StandardCharsets.UTF_8), MediaType.APPLICATION_JSON_VALUE); } /** * Creates an XML response from a String * @@ -316,7 +374,7 @@ public record Response(byte[] responseBytes, String mediaType) implements Submit * @return * Response object with a media type of "application/xml" */ - public static Response xml(String xml) { return new Response(xml.getBytes(StandardCharsets.UTF_8), MediaType.APPLICATION_XML); } + public static Response xml(String xml) { return new Response(xml.getBytes(StandardCharsets.UTF_8), MediaType.APPLICATION_XML_VALUE); } }; /** * A Temporary Redirect (302 HTTP status code) response @@ -481,7 +539,7 @@ public SubmitResponse processSubmission(Submission submission) { * ALL - process all handlers that canHandle a request. * */ - static class AfSubmitLocalProcessor implements AfSubmitProcessor { + static class AfSubmitLocalProcessor implements SpringAfSubmitProcessor { private final static Logger logger = LoggerFactory.getLogger(AfSubmitLocalProcessor.class); private static final String REMAINDER_PATH_SUFFIX = "/jcr:content/guideContainer.af.submit.jsp"; @@ -492,10 +550,10 @@ static class AfSubmitLocalProcessor implements AfSubmitProcessor { public interface InternalAfSubmitAemProxyProcessor { AfSubmitAemProxyProcessor get(); } - + private final List submissionHandlers; private final AfSubmitAemProxyProcessor aemProxyProcessor; - + AfSubmitLocalProcessor(List submissionHandlers, InternalAfSubmitAemProxyProcessor aemProxyProcessor) { this.submissionHandlers = submissionHandlers; this.aemProxyProcessor = aemProxyProcessor.get(); @@ -504,29 +562,37 @@ public interface InternalAfSubmitAemProxyProcessor { submissionHandlers.forEach(sh->logger.atDebug().addArgument(sh.getClass().getName()).log(" Found AfSubmissionHandler named '{}'.")); } } - + @Override - public Response processRequest(FormDataMultiPart inFormData, HttpHeaders headers, String remainder) { + public ResponseEntity processRequest(MultipartHttpServletRequest inFormData, String remainder) { if (!remainder.endsWith(REMAINDER_PATH_SUFFIX)) { // If the submission does not end with the expected submission suffix, then just proxy it AEM. - return aemProxyProcessor.processRequest(inFormData, headers, remainder); + return aemProxyProcessor.processRequest(inFormData, remainder); } String formName = determineFormName(remainder); Optional firstHandler = submissionHandlers.stream() .filter(sh->canHandle(sh, formName)) .findFirst(); - return firstHandler.map(h->processSubmission(h, inFormData, headers, formName)) + return firstHandler.map(h->processSubmission(h, inFormData, formName)) .orElseGet(()->errorResponse()); } - - private Response processSubmission(AfSubmissionHandler handler, FormDataMultiPart inFormData, HttpHeaders headers, String formName) { + + private ResponseEntity processSubmission(AfSubmissionHandler handler, MultipartHttpServletRequest inFormData, String formName) { logger.atInfo().addArgument(handler.getClass().getName()).log("Calling AfSubmissionHandler={}"); - return formulateResponse(handler.processSubmission(formulateSubmission(inFormData, headers, formName))); + return formulateResponse(handler.processSubmission(formulateSubmission(inFormData, formName))); } private String determineFormName(String guideContainerPath) { - return guideContainerPath.substring(0, guideContainerPath.length() - REMAINDER_PATH_SUFFIX.length()); + return extractFormName(removeLeadingSlash(guideContainerPath)); + } + + private static String extractFormName(String relativePath) { + return relativePath.substring(0, relativePath.length() - REMAINDER_PATH_SUFFIX.length()); + } + + private static String removeLeadingSlash(String path) { + return path.startsWith("/") ? path.substring(1) : path; } private boolean canHandle(AfSubmissionHandler sh, String formName) { @@ -536,7 +602,7 @@ private boolean canHandle(AfSubmissionHandler sh, String formName) { } // Create a AfSubmissionHandler.Submission object from the JAX-RS Request classes. - private AfSubmissionHandler.Submission formulateSubmission(FormDataMultiPart inFormData, HttpHeaders headers, String formName) { + private AfSubmissionHandler.Submission formulateSubmission(MultipartHttpServletRequest inFormData, String formName) { class ExtractedData { String formData; String redirectUrl; @@ -552,39 +618,52 @@ class ExtractedData { return new AfSubmissionHandler.Submission(extractedData.formData, formName, extractedData.redirectUrl, - transferHeaders(headers) + transferHeaders(inFormData.getRequestHeaders()) ); } // Transfer headers from JAX-RS construct to Spring construct (in order to keep JAX-RS encapsulated in this class) private MultiValueMapAdapter transferHeaders(HttpHeaders headers) { if (logger.isDebugEnabled()) { - headers.getRequestHeaders().forEach((k,v)->logger.atDebug().addArgument(k).addArgument(v.size()).log("Found Http header {} with {} values.")); + headers.forEach((k,v)->logger.atDebug().addArgument(k).addArgument(v.size()).log("Found Http header {} with {} values.")); } - return new MultiValueMapAdapter(headers.getRequestHeaders()); + return new MultiValueMapAdapter(headers); } // Convert the SubmitResponse object into a JAX-RS Response object. - private Response formulateResponse(AfSubmissionHandler.SubmitResponse submitResponse) { + private ResponseEntity formulateResponse(AfSubmissionHandler.SubmitResponse submitResponse) { if (submitResponse instanceof AfSubmissionHandler.SubmitResponse.Response response) { - var builder = response.responseBytes().length > 0 ? Response.ok().entity(response.responseBytes()).type(response.mediaType()) - : Response.noContent(); - return builder.build(); + return response.responseBytes().length > 0 + ? ResponseEntity.ok().contentType(MediaType.valueOf(response.mediaType())).body(response.responseBytes()) + : ResponseEntity.noContent().build(); } else if (submitResponse instanceof AfSubmissionHandler.SubmitResponse.SeeOther redirectFound) { - return Response.seeOther(redirectFound.redirectUrl()).build(); + return seeOther(redirectFound.redirectUrl()); } else if (submitResponse instanceof AfSubmissionHandler.SubmitResponse.Redirect redirect) { - return Response.temporaryRedirect(redirect.redirectUrl()).build(); + return temporaryRedirect(redirect.redirectUrl()); } else { // This cannot happen, but we need to supply an else until we can turn this code into a switch // expression in JDK 21. throw new IllegalStateException("Unexpected SubmitResponse class type '%s', this should never happen!".formatted(submitResponse.getClass().getName())); } } - + + private static ResponseEntity seeOther(URI url) { + HttpHeaders headers = new HttpHeaders(); + headers.setLocation(url); + return ResponseEntity.status(HttpStatusCode.valueOf(HttpStatus.SEE_OTHER.value())).headers(headers).build(); + } + + private static ResponseEntity temporaryRedirect(URI url) { + HttpHeaders headers = new HttpHeaders(); + headers.setLocation(url); + return ResponseEntity.status(HttpStatusCode.valueOf(HttpStatus.TEMPORARY_REDIRECT.value())).headers(headers).build(); + } + // Generate an JAX-RS Error response if not AfSubmissionHandler was found. - private Response errorResponse() { + private static ResponseEntity errorResponse() { logger.atWarn().log("No applicable AfSubmissionHandler found."); - return Response.status(Response.Status.NOT_FOUND).build(); + return ResponseEntity.notFound().build(); } } + } diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAutoConfiguration.java b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAutoConfiguration.java index 7e917dc1..1dd997ac 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAutoConfiguration.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAutoConfiguration.java @@ -9,19 +9,15 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication; import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication.Type; -import org.springframework.boot.autoconfigure.jersey.ResourceConfigCustomizer; +import org.springframework.boot.autoconfigure.web.client.RestClientSsl; import org.springframework.boot.context.properties.EnableConfigurationProperties; -import org.springframework.boot.ssl.SslBundles; -import org.springframework.boot.system.JavaVersion; import org.springframework.context.annotation.Bean; -import org.springframework.core.task.SimpleAsyncTaskExecutor; -import org.springframework.core.task.TaskExecutor; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler; -import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitAemProxyProcessor; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitLocalProcessor; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitLocalProcessor.InternalAfSubmitAemProxyProcessor; -import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitProcessor; +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitAemProxyProcessor; +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.SpringAfSubmitProcessor; /** * AutoConfiguration for the Reverse Proxy Library which reverse proxies secondary @@ -30,44 +26,33 @@ @AutoConfiguration @ConditionalOnWebApplication(type=Type.SERVLET) @ConditionalOnProperty(prefix="fluentforms.rproxy", name="enabled", havingValue="true", matchIfMissing=true ) +@ConditionalOnProperty(prefix="fluentforms.rproxy", name="type", havingValue="springmvc", matchIfMissing=true ) @EnableConfigurationProperties({AemConfiguration.class, AemProxyConfiguration.class}) +@ConditionalOnMissingBean(AemProxyImplemention.class) public class AemProxyAutoConfiguration { - + /** - * Configures the JAX-RS resources associated with reverse proxying resources and submissions from - * Adaptive Forms. + * Marker bean to indicate that the Spring MVC-based AEM Proxy implementation is being used. * - * @param aemConfig - * AEM configuration typically configured using application.properties files. This is - * typically injected by the Spring Framework. - * @param aemProxyConfig - * AEM proxy-specific configuration typically configured using application.properties files. - * This is typically injected by the Spring Framework. - * @param aemProxyTaskExecutor * @return - * JAX-RS Resource configuration customizer that is used by the spring-jersey starter to configure - * JAX-RS Resources (i.e. endpoints) */ @Bean - public ResourceConfigCustomizer afProxyConfigurer(AemConfiguration aemConfig, AemProxyConfiguration aemProxyConfig, @Autowired(required = false) SslBundles sslBundles, TaskExecutor aemProxyTaskExecutor) { - return config->config.register(new AemProxyEndpoint(aemConfig, aemProxyConfig, sslBundles, aemProxyTaskExecutor)) - .register(new AemProxyAfSubmission()) - ; + AemProxyImplemention aemProxyImplemention() { + return new AemProxyImplemention() { + // This is just a marker bean. + }; } - /** - * Supply a TaskExecutor for use by the AemProxyEndpoint. This is used to process csrf token requests because they are Chunked. - * - * @return the taskeExecutor that will be used to process csrf token requests. - */ @Bean - public TaskExecutor aemProxyTaskExecutor() { - var executor = new SimpleAsyncTaskExecutor("AemProxy-"); - // Use virtual threads if available. This will be the default for Java 21 and later. - executor.setVirtualThreads(JavaVersion.getJavaVersion().isEqualOrNewerThan(JavaVersion.TWENTY_ONE)); - return executor; + AemProxyEndpoint aemProxyEndpoint(AemConfiguration aemConfig, AemProxyConfiguration aemProxyConfig, @Autowired(required = false) RestClientSsl restClientSsl) { + return new AemProxyEndpoint(aemConfig, aemProxyConfig, restClientSsl); } + @Bean + AemProxyAfSubmission aemProxyAfSubmission(SpringAfSubmitProcessor submitProcessor) { + return new AemProxyAfSubmission(submitProcessor); + } + /** * Supply a AfSubmitLocalProcessor if the user has not already supplied one *and* there is an * available AfSubmissionHandler @@ -83,10 +68,10 @@ public TaskExecutor aemProxyTaskExecutor() { * Processor that will call the first submission handler that says that it can * process this request. */ - @ConditionalOnMissingBean(AfSubmitProcessor.class) + @ConditionalOnMissingBean(SpringAfSubmitProcessor.class) @ConditionalOnBean(AfSubmissionHandler.class) @Bean - public AfSubmitProcessor localSubmitProcessor(List submissionHandlers, InternalAfSubmitAemProxyProcessor aemProxyProcessor) { + public SpringAfSubmitProcessor localSubmitProcessor(List submissionHandlers, InternalAfSubmitAemProxyProcessor aemProxyProcessor) { return new AfSubmitLocalProcessor(submissionHandlers, aemProxyProcessor); } @@ -102,10 +87,10 @@ public AfSubmitProcessor localSubmitProcessor(List submissi * @return * Processor that forwards all submissions on to AEM. */ - @ConditionalOnMissingBean({AfSubmitProcessor.class, AfSubmissionHandler.class}) + @ConditionalOnMissingBean({SpringAfSubmitProcessor.class, AfSubmissionHandler.class}) @Bean() - public AfSubmitProcessor aemSubmitProcessor(AemConfiguration aemConfig, @Autowired(required = false) SslBundles sslBundles) { - return new AfSubmitAemProxyProcessor(aemConfig, sslBundles); + public SpringAfSubmitProcessor aemSubmitProcessor(AemConfiguration aemConfig, @Autowired(required = false) RestClientSsl restClientSsl) { + return new AfSubmitAemProxyProcessor(aemConfig, restClientSsl); } /** @@ -124,7 +109,7 @@ public AfSubmitProcessor aemSubmitProcessor(AemConfiguration aemConfig, @Autowir @ConditionalOnMissingBean(InternalAfSubmitAemProxyProcessor.class) @ConditionalOnBean(AfSubmissionHandler.class) @Bean - public InternalAfSubmitAemProxyProcessor aemProxyProcessor(AemConfiguration aemConfig, @Autowired(required = false) SslBundles sslBundles) { - return ()->new AfSubmitAemProxyProcessor(aemConfig, sslBundles); + public InternalAfSubmitAemProxyProcessor aemProxyProcessor(AemConfiguration aemConfig, @Autowired(required = false) RestClientSsl restClientSsl) { + return ()->new AfSubmitAemProxyProcessor(aemConfig, restClientSsl); } } diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyEndpoint.java b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyEndpoint.java index 794eb6eb..2804d8f0 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyEndpoint.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyEndpoint.java @@ -3,33 +3,34 @@ import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; +import java.net.URI; import java.nio.charset.StandardCharsets; +import java.util.Objects; import java.util.function.Function; import java.util.stream.Collectors; import javax.naming.ConfigurationException; -import org.glassfish.jersey.client.ChunkedInput; -import org.glassfish.jersey.server.ChunkedOutput; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.springframework.boot.ssl.SslBundles; -import org.springframework.core.task.TaskExecutor; +import org.springframework.boot.autoconfigure.web.client.RestClientSsl; +import org.springframework.boot.ssl.NoSuchSslBundleException; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.http.client.support.BasicAuthenticationInterceptor; +import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.client.RestClient; +import org.springframework.web.util.UriComponentsBuilder; import com._4point.aem.docservices.rest_services.client.helpers.ReplacingInputStream; -import jakarta.ws.rs.GET; -import jakarta.ws.rs.HeaderParam; -import jakarta.ws.rs.POST; -import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; -import jakarta.ws.rs.client.Client; -import jakarta.ws.rs.client.Entity; -import jakarta.ws.rs.client.WebTarget; -import jakarta.ws.rs.core.GenericType; -import jakarta.ws.rs.core.MediaType; -import jakarta.ws.rs.core.Response; - /** * Reverse Proxy Code which reverse proxies secondary resources (.css, .js, etc.) that the browser will request. * These requests are forwarded to AEM. @@ -42,74 +43,64 @@ * get the AdaptiveForm or HTML5 Form using the FLuentForms libraries. * */ -@Path("/aem") +@CrossOrigin +@RestController +@RequestMapping("/aem") public class AemProxyEndpoint { private final static Logger logger = LoggerFactory.getLogger(AemProxyEndpoint.class); private static final String AEM_APP_PREFIX = "/"; - private Client httpClient; + private final RestClient httpClient; private final AemProxyConfiguration aemProxyConfig; private final AemConfiguration aemConfig; - private final TaskExecutor taskExecutor; /** * */ - public AemProxyEndpoint(AemConfiguration aemConfig, AemProxyConfiguration aemProxyConfig, SslBundles sslBundles, TaskExecutor taskExecutor) { + public AemProxyEndpoint(AemConfiguration aemConfig, AemProxyConfiguration aemProxyConfig, RestClientSsl restClientSsl) { this.aemProxyConfig = aemProxyConfig; this.aemConfig = aemConfig; - this.httpClient = JerseyClientFactory.createClient(sslBundles, aemConfig.sslBundle(), aemConfig.user(), aemConfig.password()); - this.taskExecutor = taskExecutor; + this.httpClient = createClient(aemConfig, RestClient.builder(), restClientSsl); } - @Path("libs/granite/csrf/token.json") - @GET - public ChunkedOutput proxyOsgiCsrfToken() throws IOException { + @GetMapping("/libs/granite/csrf/token.json") + public ResponseEntity proxyOsgiCsrfToken() throws IOException { final String path = AEM_APP_PREFIX + "libs/granite/csrf/token.json"; return getCsrfToken(path); } - @Path("lc/libs/granite/csrf/token.json") - @GET - public ChunkedOutput proxyJeeCsrfToken() throws IOException { + @GetMapping("/lc/libs/granite/csrf/token.json") + public ResponseEntity proxyJeeCsrfToken() throws IOException { final String path = "/lc/libs/granite/csrf/token.json"; return getCsrfToken(path); } - private ChunkedOutput getCsrfToken(final String path) { + private ResponseEntity getCsrfToken(final String path) { logger.atDebug().log("Proxying GET request. CSRF token"); - WebTarget webTarget = httpClient.target(aemConfig.url()) - .path(path); - logger.atDebug().log(()->"Proxying GET request for CSRF token '" + webTarget.getUri().toString() + "'."); - Response result = webTarget.request() - .get(); - - logger.atDebug().log(()->"CSRF token GET response status = " + result.getStatus()); - final ChunkedInput chunkedInput = result.readEntity(new GenericType>() {}); - final ChunkedOutput output = new ChunkedOutput(byte[].class); - taskExecutor.execute(() -> { - try (result; chunkedInput; output) { - byte[] chunk; - while ((chunk = chunkedInput.read()) != null) { - output.write(chunk); - logger.debug("Returning GET chunk for CSRF token."); - } - logger.debug("Finished GETting chunks for CSRF token."); - } catch (IllegalStateException | IOException e) { - e.printStackTrace(); - } - logger.debug("Exiting Thread."); - }); + URI uri = UriComponentsBuilder.fromUriString(aemConfig.url()) + .path(path) + .build() + .toUri(); + + logger.atDebug().log(()->"Proxying GET request for CSRF token '" + uri.toString() + "'."); + ResponseEntity response = httpClient.get() + .uri(uri) + .retrieve() + .toEntity(byte[].class); + + logger.atDebug() + .addArgument(()->response.getStatusCode().toString()) + .log(()->"CSRF token GET response status = {}"); logger.atDebug().log("Returning GET response for CSRF token."); - return output; + return ResponseEntity.status(response.getStatusCode()) + .headers(removeChunkedTransferEncoding(response.getHeaders())) + .body(response.getBody()); } - - /** * This function acts as a reverse proxy for anything under clientlibs. It just forwards * anything it receives on AEM and then returns the response. @@ -118,31 +109,54 @@ private ChunkedOutput getCsrfToken(final String path) { * @return * @throws ConfigurationException */ - @Path("{remainder : .+}") - @GET - public Response proxyGet(@PathParam("remainder") String remainder) { + @GetMapping("/{*remainder}") + public ResponseEntity proxyGet(@PathVariable("remainder") String remainder) { logger.atDebug().log(()->"Proxying GET request. remainder=" + remainder); - WebTarget webTarget = httpClient.target(aemConfig.url()) - .path(AEM_APP_PREFIX + remainder); - logger.atDebug().log(()->"Proxying GET request for target '" + webTarget.getUri().toString() + "'."); - Response result = webTarget.request() - .get(); + URI uri = UriComponentsBuilder.fromUriString(aemConfig.url()) + .path(AEM_APP_PREFIX + remainder) + .build() + .toUri(); + logger.atDebug().log(()->"Proxying GET request for target '" + uri.toString() + "'."); + ResponseEntity response = httpClient.get() + .uri(uri) + .retrieve() + .toEntity(byte[].class); + if (logger.isDebugEnabled()) { - result.getHeaders().forEach((h, l)->logger.atDebug().log("For " + webTarget.getUri().toString() + ", Header:" + h + "=" + l.stream().map(o->(String)o).collect(Collectors.joining("','", "'", "'")))); + response.getHeaders().forEach((h, l)->logger.atDebug().log("For " + uri + ", Header:" + h + "=" + l.stream().map(o->(String)o).collect(Collectors.joining("','", "'", "'")))); } - logger.atDebug().log(()->"Returning GET response from target '" + webTarget.getUri().toString() + "' status code=" + result.getStatus() + "."); + logger.atDebug().log(()->"Returning GET response from target '" + uri + "' status code=" + response.getStatusCode().value() + "."); Function filter = switch (remainder) { - case "etc.clientlibs/clientlibs/granite/utils.js" -> this::substituteAfBaseLocation; - case "etc.clientlibs/fd/xfaforms/clientlibs/profile.js" -> this::fixTogglesDotJsonLocation; + case "/etc.clientlibs/clientlibs/granite/utils.js" -> this::substituteAfBaseLocation; + case "/etc.clientlibs/fd/xfaforms/clientlibs/profile.js" -> AemProxyEndpoint::fixTogglesDotJsonLocation; default -> is -> is; // No filtering needed }; - return Response.fromResponse(result) - .header("Transfer-Encoding", null) // Remove the Transfer-Encoding header - .entity(filter.apply(result.readEntity(InputStream.class))) - .build(); + return ResponseEntity.status(response.getStatusCode()) + .headers(removeChunkedTransferEncoding(response.getHeaders())) + .body(filterByteArray(response.getBody(), filter)); } + // Remove transfer-encoding header to prevent chunked encoding issues. + private static HttpHeaders removeChunkedTransferEncoding(HttpHeaders headers) { + var transferEncoding = headers.getFirst(HttpHeaders.TRANSFER_ENCODING); + if (transferEncoding != null && transferEncoding.equalsIgnoreCase("chunked")) { + var newHeaders = new HttpHeaders(headers); + newHeaders.remove(HttpHeaders.TRANSFER_ENCODING); + return newHeaders; + } + return headers; + } + + // passes a byte array through an InputStream filter and returns the result as a byte array. + private static byte[] filterByteArray(byte[] input, Function isFilter) { + try (var bais = new ByteArrayInputStream(input)) { + return isFilter.apply(bais).readAllBytes(); + } catch (IOException e) { + throw new IllegalStateException("This should never happen - ", e); + } + } + /** * Wraps an InputStream with a wrapper that replaces some code in the Adobe utils.js code. * @@ -167,61 +181,97 @@ private InputStream substituteAfBaseLocation(InputStream is) { } } - private InputStream fixTogglesDotJsonLocation(InputStream is) { + private static InputStream fixTogglesDotJsonLocation(InputStream is) { String target = "\"/etc.clientlibs/toggles.json\""; String replacement = "\"/aem/etc.clientlibs/toggles.json\""; logger.atDebug().log("Altering profile.js to replace '{}' with '{}'", target, replacement); return new ReplacingInputStream(is, target, replacement); } - @Path("{remainder : .+}") - @POST - public Response proxyPost(@PathParam("remainder") String remainder, @HeaderParam("Content-Type") String contentType, InputStream in) { + @PostMapping("/{*remainder}") + public ResponseEntity proxyPost(@PathVariable("remainder") String remainder, @RequestHeader(value = "Content-Type", required = false) String contentType, byte[] in) { logger.atDebug().log("Proxying POST request. remainder={}", remainder); - WebTarget webTarget = httpClient.target(aemConfig.url()) - .path(AEM_APP_PREFIX + remainder); - logger.atDebug().addArgument(()->webTarget.getUri().toString()) - .addArgument(contentType) - .log(()->"Proxying POST request for target '{}'. ContentType='{}'."); - Response result = webTarget.request() - .post(Entity.entity( - logger.isDebugEnabled() ? debugInput(in, webTarget.getUri().toString()) : in, // if Debug is on, write out information about input stream - contentType != null ? contentType : "application/octet-stream" // supply default content type if it was omitted. - )); + URI uri = UriComponentsBuilder.fromUriString(aemConfig.url()) + .path(AEM_APP_PREFIX + remainder) + .build() + .toUri(); + logger.atDebug().addArgument(()->uri.toString()) + .addArgument(contentType) + .log(()->"Proxying POST request for target '{}'. ContentType='{}'."); + + ResponseEntity response = httpClient.post() + .uri(uri) + .body(debugInput(Objects.requireNonNullElseGet(in, ()->new byte[0]), uri.toString())) // if Debug is on, write out information about input stream + .contentType(contentType != null ? MediaType.valueOf(contentType) : MediaType.APPLICATION_OCTET_STREAM) // supply default content type if it was omitted. + .retrieve() + .toEntity(byte[].class); if (remainder.contains("af.submit.jsp")) { - logger.atDebug().addArgument(()->Boolean.valueOf(result == null).toString()) + logger.atDebug().addArgument(()->Boolean.valueOf(response == null).toString()) .log("result == null is {}."); - MediaType mediaType = result.getMediaType(); + MediaType mediaType = response.getHeaders().getContentType(); logger.atDebug() - .addArgument(()->webTarget.getUri().toString()) + .addArgument(()->uri.toString()) .addArgument(()->mediaType != null ? mediaType.toString() : "") - .addArgument(()->result.getHeaderString("Transfer-Encoding")) + .addArgument(()->response.getHeaders().getFirst("Transfer-Encoding")) .log("Returning POST response from target '{}'. contentType='{}'. transfer-encoding='{}'."); } else { logger.atDebug() - .addArgument(webTarget.getUri()::toString) + .addArgument(uri::toString) .log("Returning POST response from target '{}'."); } - return Response.fromResponse(result).build(); + return response; } - private InputStream debugInput(InputStream in, String target) { - try { - byte[] inputBytes = in.readAllBytes(); - logger.atDebug() - .log("Proxying POST request for target '{}'. numberOfBytes proxied='{}'.", target, inputBytes.length); - logger.atTrace() - .addArgument(target) - .addArgument(()->new String(inputBytes, StandardCharsets.UTF_8)) - .log("Proxying POST request for target '{}'. input bytes proxied='{}'."); - return new ByteArrayInputStream(inputBytes); - } catch (IOException e) { - logger.atError() - .setCause(e) - .log("Error reading input stream."); - return new ByteArrayInputStream(new byte[0]); - } + private static byte[] debugInput(byte[] inputBytes, String target) { + logger.atDebug() + .log("Proxying POST request for target '{}'. numberOfBytes proxied='{}'.", target, inputBytes.length); + logger.atTrace() + .addArgument(target) + .addArgument(()->new String(inputBytes, StandardCharsets.UTF_8)) + .log("Proxying POST request for target '{}'. input bytes proxied='{}'."); + return inputBytes; } + + private static RestClient createClient( + AemConfiguration aemConfig, + RestClient.Builder builder, + RestClientSsl restClientSsl + ) { + + if (aemConfig.useSsl()) { + configureSsl(builder, restClientSsl, aemConfig.sslBundle()); + } else { + logger.info("Creating default client."); + } + + if (aemConfig.user() != null) { + configureBasicAuth(builder, aemConfig.user(), aemConfig.password()); + } + + return builder.baseUrl(aemConfig.url()) + .build(); + } + + private static void configureBasicAuth(RestClient.Builder builder, String username, String password) { + builder.requestInterceptor(new BasicAuthenticationInterceptor(username, password)); + } + + private static void configureSsl(RestClient.Builder builder, RestClientSsl restClientSsl, String bundleName) { + if (restClientSsl != null && bundleName != null) { + logger.info("Using Client ssl bundle: '" + bundleName + "'."); + try { + builder.apply(restClientSsl.fromBundle(bundleName)); + } catch (NoSuchSslBundleException e) { + // Eat the exception and fall through to the default client + // Default the SSL context (which includes the default trust store) + logger.warn("Unable to locate ssl bundle '" + bundleName + "'. Creating default client."); + } + } else if (restClientSsl == null && bundleName != null) { + throw new IllegalStateException("RestClientSsl is null, unable to configure SSL bundle '" + bundleName + "'."); + } else { /* bundlename == null */ + logger.info("AEM bundleName is null. Creating default client."); + } + } } diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyImplemention.java b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyImplemention.java new file mode 100644 index 00000000..42b26f10 --- /dev/null +++ b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyImplemention.java @@ -0,0 +1,9 @@ +package com._4point.aem.fluentforms.spring; + +/** + * This is a placeholder interface used to identify the AEM Proxy Implementation, Each implementation + * (spring-mvc, jersey, etc.) will provide a bean that implements this one so that only one implementation is used. + */ +public interface AemProxyImplemention { + +} diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/FluentFormsAutoConfiguration.java b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/FluentFormsAutoConfiguration.java index 659fe806..00a99df8 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/FluentFormsAutoConfiguration.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/FluentFormsAutoConfiguration.java @@ -4,17 +4,14 @@ import java.util.function.Consumer; import java.util.function.Function; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.AutoConfiguration; -import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.web.client.RestClientSsl; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.ssl.NoSuchSslBundleException; -import org.springframework.boot.ssl.SslBundles; import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Fallback; import org.springframework.context.annotation.Lazy; import org.springframework.web.client.RestClient; @@ -29,7 +26,6 @@ import com._4point.aem.docservices.rest_services.client.helpers.FormsFeederUrlFilterBuilder; import com._4point.aem.docservices.rest_services.client.helpers.StandardFormsFeederUrlFilters; import com._4point.aem.docservices.rest_services.client.html5.Html5FormsService; -import com._4point.aem.docservices.rest_services.client.jersey.JerseyRestClient; import com._4point.aem.docservices.rest_services.client.output.RestServicesOutputServiceAdapter; import com._4point.aem.docservices.rest_services.client.pdfUtility.RestServicesPdfUtilityServiceAdapter; import com._4point.aem.fluentforms.api.DocumentFactory; @@ -51,7 +47,6 @@ import com._4point.aem.fluentforms.impl.pdfUtility.PdfUtilityServiceImpl; import com._4point.aem.fluentforms.spring.rest_services.client.SpringRestClientRestClient; -import jakarta.ws.rs.client.Client; /** * AutoConfiguration for the FluentForms Rest Services Client library. @@ -64,8 +59,6 @@ @AutoConfiguration @EnableConfigurationProperties(AemConfiguration.class) public class FluentFormsAutoConfiguration { - // // TODO: Either call JerseuRestClient.factory(JerseyClientFactory.createClient(sslBundles, aemConfig.sslBundle())) or create SpringRestClient -// private static final BiFunction restClientFactory = (b, s)->JerseyRestClient.factory(JerseyClientFactory.createClient(b, s)); @SuppressWarnings("unchecked") private T setAemFields(T builder, AemConfiguration aemConfig) { @@ -77,11 +70,10 @@ private T setAemFields(T builder, AemConfiguration aemConfig } - // matchIfMissing is currently set to false so that, by default (if nothing is specified in the properties file), then the JersetRestClient is used. - // To use the SpringRestClient, set fluentforms.restclient.springrestclient.enabled=true - // At some point, we may want to set matchIfMissing=true which would make the SpringRestClient the default.. - @ConditionalOnProperty(prefix="fluentforms", name="restclient", havingValue="springrestclient", matchIfMissing=false ) + // matchIfMissing is set to true so that, by default (if nothing is specified in the properties file), then the SpringRestClient is used. + @ConditionalOnProperty(prefix="fluentforms", name="restclient", havingValue="springrestclient", matchIfMissing=true ) @ConditionalOnMissingBean + @Fallback @Bean public RestClientFactory springRestClientFactory(AemConfiguration aemConfig, RestClient.Builder restClientBuilder, RestClientSsl restClientSsl) { return SpringRestClientRestClient.factory(aemConfig.useSsl() ? restClientBuilder.apply(getSslBundle(aemConfig.sslBundle(), restClientSsl)) @@ -89,8 +81,7 @@ public RestClientFactory springRestClientFactory(AemConfiguration aemConfig, Res ); // Create a RestClientFactory using Spring RestClient implementation } - - private Consumer getSslBundle(String sslBundleName, RestClientSsl restClientSsl) { + private static Consumer getSslBundle(String sslBundleName, RestClientSsl restClientSsl) { try { return restClientSsl.fromBundle(sslBundleName); } catch (NoSuchSslBundleException e) { @@ -101,22 +92,7 @@ private Consumer getSslBundle return b->{}; // No-op; } } - - @Configuration(proxyBeanMethods = false) - @ConditionalOnClass(org.glassfish.jersey.client.JerseyClient.class) - public static class JerseyRestClientConfiguration { - - @ConditionalOnProperty(prefix="fluentforms", name="restclient", havingValue="jersey", matchIfMissing=true ) - @ConditionalOnMissingBean - @Bean - public RestClientFactory jerseyRestClientFactory(AemConfiguration aemConfig, @Autowired(required = false) SslBundles sslBundles) { - Client jerseyClient = JerseyClientFactory.createClient(sslBundles, aemConfig.sslBundle()); // Create custom Jersey Client with SSL bundle - return JerseyRestClient.factory(jerseyClient); // Create a RestClientFactory using JerseyClient implementation - } - } - - @ConditionalOnMissingBean @Bean public AdaptiveFormsService adaptiveFormsService(AemConfiguration aemConfig, Function afInputStreamFilter, RestClientFactory restClientFactory) { diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmissionTest.java b/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmissionTest.java index 39a739b3..960760fa 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmissionTest.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmissionTest.java @@ -1,7 +1,5 @@ package com._4point.aem.fluentforms.spring; -import static com._4point.aem.fluentforms.spring.AemProxyAfSubmissionTest.TestApplication.JerseyConfig; -import static com._4point.testing.matchers.jaxrs.ResponseMatchers.*; import static com._4point.testing.matchers.javalang.ExceptionMatchers.*; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*; @@ -13,10 +11,10 @@ import java.util.List; import java.util.function.Function; -import org.glassfish.jersey.client.ClientProperties; -import org.glassfish.jersey.media.multipart.FormDataMultiPart; -import org.glassfish.jersey.media.multipart.MultiPartFeature; -import org.glassfish.jersey.server.ResourceConfig; +import org.hamcrest.Description; +import org.hamcrest.FeatureMatcher; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -35,25 +33,29 @@ import org.springframework.boot.test.web.server.LocalServerPort; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.HttpStatusCode; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Component; +import org.springframework.util.LinkedMultiValueMap; +import org.springframework.util.MultiValueMap; +import org.springframework.web.client.RestClient; +import org.springframework.web.multipart.MultipartHttpServletRequest; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitAemProxyProcessor; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitLocalProcessor; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler; -import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitProcessor; +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.SpringAfSubmitProcessor; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler.SubmitResponse; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitLocalProcessor.InternalAfSubmitAemProxyProcessor; import com._4point.aem.fluentforms.spring.AemProxyAfSubmissionTest.AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest.MockAemProxy; import com.github.tomakehurst.wiremock.client.WireMock; import com.github.tomakehurst.wiremock.core.WireMockConfiguration; import com.github.tomakehurst.wiremock.junit5.WireMockExtension; - -import jakarta.ws.rs.client.ClientBuilder; -import jakarta.ws.rs.client.Entity; -import jakarta.ws.rs.client.WebTarget; -import jakarta.ws.rs.core.HttpHeaders; -import jakarta.ws.rs.core.MediaType; -import jakarta.ws.rs.core.Response; +import com.github.tomakehurst.wiremock.verification.LoggedRequest; /** * Tests for AemProxyAfSubmissions classes. @@ -65,23 +67,52 @@ class AemProxyAfSubmissionTest { public static final String AF_TEMPLATE_NAME = "sample00002test"; private static final String SUBMIT_ADAPTIVE_FORM_SERVICE_PATH = "/aem/content/forms/af/" + AF_TEMPLATE_NAME + "/jcr:content/guideContainer.af.submit.jsp"; private static final String AEM_SUBMIT_ADAPTIVE_FORM_SERVICE_PATH = SUBMIT_ADAPTIVE_FORM_SERVICE_PATH.substring(4); // Same as above minus "/aem" - public static final MediaType APPLICATION_PDF = new MediaType("application", "pdf"); private static final String SAMPLE_RESPONSE_BODY = "body"; - record JakartaRestClient(WebTarget target, URI uri) {}; - - public static JakartaRestClient setUpRestClient(int port) { - var uri = getBaseUri(port); - var target = ClientBuilder.newClient() //newClient(clientConfig) - .property(ClientProperties.FOLLOW_REDIRECTS, Boolean.FALSE) // Disable re-directs so that we can test for "thank you page" redirection. - .register(MultiPartFeature.class) - .target(uri); - return new JakartaRestClient(target, uri); +// record JakartaRestClient(WebTarget target, URI uri) {}; +// +// public static JakartaRestClient setUpRestClient(int port) { +// var uri = getBaseUri(port); +// var target = ClientBuilder.newClient() //newClient(clientConfig) +// .property(ClientProperties.FOLLOW_REDIRECTS, Boolean.FALSE) // Disable re-directs so that we can test for "thank you page" redirection. +// .register(MultiPartFeature.class) +// .target(uri); +// return new JakartaRestClient(target, uri); +// } + + private static RestClient createRestClient(int port) { + return RestClient.builder() + .baseUrl(getBaseUri(port)) + .build(); } + + record FormDataMultiPart(MultiValueMap> parts) { + public FormDataMultiPart() { + this(new LinkedMultiValueMap<>()); + } + + public FormDataMultiPart field(String fieldName, String fieldData) { + internalAdd(fieldName, fieldData, MediaType.TEXT_PLAIN); + return this; + } + public FormDataMultiPart field(String fieldName, byte[] fieldData) { + internalAdd(fieldName, fieldData, MediaType.APPLICATION_OCTET_STREAM); + return this; + } + + private void internalAdd(String fieldName, Object fieldData, MediaType contentType) { + parts.add(fieldName, new HttpEntity<>(fieldData, new HttpHeaders() { + { + setContentType(contentType); + } + })); + } + } + /* package */ static FormDataMultiPart mockFormData(String redirect, String data) { - final FormDataMultiPart getPdfForm = new FormDataMultiPart(); + var getPdfForm = new FormDataMultiPart(); getPdfForm.field("guideContainerPath", "/aem/content/forms/af/" + AF_TEMPLATE_NAME + "/jcr:content/guideContainer") .field("aemFormComponentPath", "") .field("_asyncSubmit", "false") @@ -112,10 +143,6 @@ public static class TestApplication { public static void main(String[] args) { SpringApplication.run(TestApplication.class, args); } - - @Component - public static class JerseyConfig extends ResourceConfig { - } } /** @@ -123,9 +150,9 @@ public static class JerseyConfig extends ResourceConfig { * */ @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, - classes = {TestApplication.class, JerseyConfig.class, AfSubmitAemProxyProcessor.class}, + classes = {TestApplication.class, AfSubmitAemProxyProcessor.class}, properties = { -// "debug", + "debug", "fluentforms.aem.servername=" + "localhost", "fluentforms.aem.port=" + "8502", "fluentforms.aem.user=admin", @@ -153,11 +180,13 @@ public static class AemProxyAfSubmissionTestWithAemAfSubmitProcessorTest { @LocalServerPort private int port; - private JakartaRestClient jrc; +// private JakartaRestClient jrc; + private RestClient restClient; @BeforeEach public void setUp() throws Exception { - jrc = setUpRestClient(port); +// jrc = setUpRestClient(port); + restClient = createRestClient(port); } @Test @@ -170,15 +199,35 @@ void test() { final FormDataMultiPart getPdfForm = mockFormData("foo", "bar"); // when - Response response = jrc.target.path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH).request().accept(APPLICATION_PDF) - .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + MultiValueMap> parts = getPdfForm.parts(); + ResponseEntity response = restClient.post() + .uri(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) +// .contentType(MediaType.MULTIPART_FORM_DATA) + .body(parts) + .accept(MediaType.APPLICATION_PDF) + .retrieve() + .toEntity(byte[].class) + ; + +// .target.path().request().accept(APPLICATION_PDF) +// .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); // then - assertThat(response, allOf(isStatus(Response.Status.OK),hasEntityMatching(equalTo(expectedResponseString.getBytes())))); + assertThat(response, allOf(hasStatus(HttpStatus.OK), hasEntityMatching(equalTo(expectedResponseString.getBytes())))); WireMock.verify( - WireMock.postRequestedFor(WireMock.urlEqualTo(AEM_SUBMIT_ADAPTIVE_FORM_SERVICE_PATH)) - .withAnyRequestBodyPart(WireMock.aMultipart("jcr:data").withBody(WireMock.equalTo("bar"))) +// WireMock.postRequestedFor(WireMock.urlMatching(AEM_SUBMIT_ADAPTIVE_FORM_SERVICE_PATH)) +// .withAnyRequestBodyPart(WireMock.aMultipart("jcr:data").withBody(WireMock.equalTo("bar"))) + WireMock.postRequestedFor(WireMock.urlMatching(AEM_SUBMIT_ADAPTIVE_FORM_SERVICE_PATH)) +// .withAnyRequestBodyPart(WireMock.aMultipart("jcr:data")) ); + + System.out.println("Writing to: " + SUBMIT_ADAPTIVE_FORM_SERVICE_PATH); + LoggedRequest loggedRequest = WireMock.findAll(WireMock.postRequestedFor(WireMock.urlEqualTo(AEM_SUBMIT_ADAPTIVE_FORM_SERVICE_PATH))).get(0); + String requestBody = loggedRequest.getBodyAsString(); + System.out.println("Request Body:\n" + requestBody); + loggedRequest.getAllHeaderKeys().forEach(headerName -> { + System.out.println("Header: " + headerName + " = " + loggedRequest.getHeader(headerName)); + }); } } @@ -188,7 +237,7 @@ void test() { * */ @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, - classes = {TestApplication.class, JerseyConfig.class, AfSubmitLocalProcessor.class, MockAemProxy.class, + classes = {TestApplication.class, AfSubmitLocalProcessor.class, MockAemProxy.class, AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest.MockSubmissionProcessor.class, AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest.MockSubmissionProcessor2.class} ,properties={ @@ -204,11 +253,13 @@ public static class AemProxyAfSubmissionTestWithLocalAfSubmitProcessorTest { @LocalServerPort private int port; - private JakartaRestClient jrc; +// private JakartaRestClient jrc; + private RestClient restClient; @BeforeEach public void setUp() throws Exception { - jrc = setUpRestClient(port); +// jrc = setUpRestClient(port); + restClient = createRestClient(port); } @@ -216,52 +267,86 @@ public void setUp() throws Exception { void testResponse() { final FormDataMultiPart getPdfForm = mockFormData("foo1", "bar"); - Response response = jrc.target - .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) - .request() - .accept(MediaType.TEXT_PLAIN_TYPE) - .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); - - assertThat(response, allOf(isStatus(Response.Status.OK),hasEntityMatching(equalTo(AF_SUBMIT_LOCAL_PROCESSOR_RESPONSE.getBytes())))); + ResponseEntity response = restClient.post() + .uri(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) + .contentType(MediaType.MULTIPART_FORM_DATA) + .body(getPdfForm.parts()) + .accept(MediaType.TEXT_PLAIN) + .retrieve() + .toEntity(byte[].class) + ; + +// Response response = jrc.target +// .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) +// .request() +// .accept(MediaType.TEXT_PLAIN_TYPE) +// .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(hasStatus(HttpStatus.OK),hasEntityMatching(equalTo(AF_SUBMIT_LOCAL_PROCESSOR_RESPONSE.getBytes())))); } @Test void testRedirect() { final FormDataMultiPart getPdfForm = mockFormData("foo2", "bar"); - Response response = jrc.target - .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) - .request() - .accept(MediaType.TEXT_PLAIN_TYPE) - .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); - - assertThat(response, allOf(isStatus(Response.Status.TEMPORARY_REDIRECT), doesNotHaveEntity())); + ResponseEntity response = restClient.post() + .uri(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) + .contentType(MediaType.MULTIPART_FORM_DATA) + .body(getPdfForm.parts()) + .accept(MediaType.TEXT_PLAIN) + .retrieve() + .toBodilessEntity() + ; +// Response response = jrc.target +// .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) +// .request() +// .accept(MediaType.TEXT_PLAIN_TYPE) +// .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(hasStatus(HttpStatus.TEMPORARY_REDIRECT), doesNotHaveEntity())); } @Test void testSeeOther() { final FormDataMultiPart getPdfForm = mockFormData("foo3", "bar"); - Response response = jrc.target - .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) - .request() - .accept(MediaType.TEXT_PLAIN_TYPE) - .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); - - assertThat(response, allOf(isStatus(Response.Status.SEE_OTHER), doesNotHaveEntity())); + ResponseEntity response = restClient.post() + .uri(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) +// .contentType(MediaType.MULTIPART_FORM_DATA) + .body(getPdfForm.parts()) + .accept(MediaType.TEXT_PLAIN) + .retrieve() + .toBodilessEntity() + ; +// Response response = jrc.target +// .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) +// .request() +// .accept(MediaType.TEXT_PLAIN_TYPE) +// .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(hasStatus(HttpStatus.SEE_OTHER), doesNotHaveEntity())); } @Test void testProxy() { final FormDataMultiPart getPdfForm = mockFormData("foo2", "bar"); - Response response = jrc.target - .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH+"anythingElse") - .request() - .accept(MediaType.TEXT_PLAIN_TYPE) - .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); - - assertThat(response, allOf(isStatus(Response.Status.OK), doesNotHaveEntity())); + ResponseEntity response = restClient.post() + .uri(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH+"anythingElse") + .contentType(MediaType.MULTIPART_FORM_DATA) + .body(getPdfForm.parts()) + .accept(MediaType.TEXT_PLAIN) + .retrieve() + .toBodilessEntity() + ; + +// Response response = jrc.target +// .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH+"anythingElse") +// .request() +// .accept(MediaType.TEXT_PLAIN_TYPE) +// .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(hasStatus(HttpStatus.OK), doesNotHaveEntity())); } @Component @@ -283,8 +368,8 @@ public SubmitResponse processSubmission(Submission submission) { ()->assertEquals(AF_TEMPLATE_NAME, submission.formName()), ()->assertEquals("bar", submission.formData()), ()->assertThat(submission.redirectUrl(), anyOf(equalTo("foo1"), equalTo("foo2"), equalTo("foo3"))), - ()->assertEquals(MediaType.TEXT_PLAIN, submission.headers().getFirst("accept")), - ()->assertTrue(MediaType.MULTIPART_FORM_DATA_TYPE.isCompatible(MediaType.valueOf(submission.headers().getFirst("content-type")))) + ()->assertEquals(MediaType.TEXT_PLAIN_VALUE, submission.headers().getFirst("accept")), + ()->assertTrue(MediaType.MULTIPART_FORM_DATA.isCompatibleWith(MediaType.valueOf(submission.headers().getFirst("content-type")))) ); try { String redirectUrl = submission.redirectUrl(); @@ -321,7 +406,7 @@ public static class MockAemProxy { @Bean() public InternalAfSubmitAemProxyProcessor aemProxyProcessor() { AfSubmitAemProxyProcessor mock = Mockito.mock(AfSubmitAemProxyProcessor.class); - Mockito.when(mock.processRequest(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(Response.ok().build()); + Mockito.when(mock.processRequest(Mockito.any(), Mockito.any())).thenReturn(ResponseEntity.ok().build()); return ()->mock; } } @@ -332,40 +417,55 @@ public InternalAfSubmitAemProxyProcessor aemProxyProcessor() { * */ @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, - classes = {TestApplication.class, JerseyConfig.class, AemProxyAfSubmissionTestWithCustomAfSubmitProcessorTest.MockSubmitProcessor.class} -// ,properties="debug" + classes = {TestApplication.class, AemProxyAfSubmissionTestWithCustomAfSubmitProcessorTest.MockSubmitProcessor.class} +// ,properties= { +// "debug" +// ,"logging.level.com._4point.aem.fluentforms.spring=DEBUG" +// ,"logging.level.org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping=TRACE" +// } ) public static class AemProxyAfSubmissionTestWithCustomAfSubmitProcessorTest { @LocalServerPort private int port; - private JakartaRestClient jrc; +// private JakartaRestClient jrc; + private RestClient restClient; @BeforeEach public void setUp() throws Exception { - jrc = setUpRestClient(port); +// jrc = setUpRestClient(port); + restClient = createRestClient(port); } @Test void test() { final FormDataMultiPart getPdfForm = mockFormData("foo", "bar"); - Response response = jrc.target - .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) - .request() - .accept(APPLICATION_PDF) - .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); - - assertThat(response, allOf(isStatus(Response.Status.OK), hasEntityMatching(equalTo(SAMPLE_RESPONSE_BODY.getBytes())))); + MultiValueMap> parts = getPdfForm.parts(); + ResponseEntity response = restClient.post() + .uri(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) +// .contentType(MediaType.MULTIPART_FORM_DATA) + .body(parts) + .accept(MediaType.APPLICATION_PDF) + .retrieve() + .toEntity(byte[].class) + ; +// Response response = jrc.target +// .path(SUBMIT_ADAPTIVE_FORM_SERVICE_PATH) +// .request() +// .accept(APPLICATION_PDF) +// .post(Entity.entity(getPdfForm, getPdfForm.getMediaType())); + + assertThat(response, allOf(hasStatus(HttpStatus.OK), hasEntityMatching(equalTo(SAMPLE_RESPONSE_BODY.getBytes())))); } @Component - public static class MockSubmitProcessor implements AfSubmitProcessor { + public static class MockSubmitProcessor implements SpringAfSubmitProcessor { @Override - public Response processRequest(FormDataMultiPart inFormData, HttpHeaders headers, String remainder) { - return Response.ok().entity(SAMPLE_RESPONSE_BODY).build(); + public ResponseEntity processRequest(MultipartHttpServletRequest inFormData, String remainder) { + return ResponseEntity.ok().body(SAMPLE_RESPONSE_BODY.getBytes()); } } } @@ -477,4 +577,66 @@ void testcanHandleFormNameMatchesRegEx(String formNameIn, boolean expectedResult assertEquals(expectedResult, underTest.canHandle(formNameIn)); } } + + private static Matcher isStatus(HttpStatusCode statusCode) { + return new TypeSafeDiagnosingMatcher() { + + @Override + public void describeTo(Description description) { + description.appendText("HttpStatus with value " + statusCode.value()); + } + + @Override + protected boolean matchesSafely(HttpStatusCode item, Description mismatchDescription) { + if (statusCode.isSameCodeAs(item)) { + return true; + } else { + mismatchDescription.appendText("was HttpStatus with value " + item.value()); + return false; + } + } + }; + } + + private static Matcher> doesNotHaveEntity() { + return new TypeSafeDiagnosingMatcher>() { + + @Override + public void describeTo(Description description) { + description.appendText("ResponseEntity with no body"); + } + + @Override + protected boolean matchesSafely(ResponseEntity item, Description mismatchDescription) { + if (item.hasBody() == false) { + return true; + } else { + mismatchDescription.appendText("was ResponseEntity with body of size " + ((byte[])item.getBody()).length); + return false; + } + } + + }; + } + + + private static Matcher> hasStatus(HttpStatusCode status) { + return new FeatureMatcher, HttpStatusCode>(isStatus(status), "ResponseEntity with status", "status") { + + @Override + protected HttpStatusCode featureValueOf(ResponseEntity actual) { + return actual.getStatusCode(); + } + }; + } + + private static Matcher> hasEntityMatching(Matcher matcher) { + return new FeatureMatcher, byte[]>(matcher, "ResponseEntity with entity matching", "entity") { + + @Override + protected byte[] featureValueOf(ResponseEntity actual) { + return (byte[]) actual.getBody(); + } + }; + } } diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAutoConfigurationTest.java b/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAutoConfigurationTest.java index ec190091..7cafea43 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAutoConfigurationTest.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAutoConfigurationTest.java @@ -6,7 +6,6 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; -import org.springframework.boot.autoconfigure.jersey.ResourceConfigCustomizer; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.test.context.SpringBootTest; @@ -19,10 +18,11 @@ }) class AemProxyAutoConfigurationTest { - @Test - void testDocumentFactory(@Autowired ResourceConfigCustomizer afProxyConfigurer) { - assertNotNull(afProxyConfigurer); - } + // TODO: Maybe add more tests here later. +// @Test +// void testDocumentFactory(@Autowired ResourceConfigCustomizer afProxyConfigurer) { +// assertNotNull(afProxyConfigurer); +// } @SpringBootApplication @EnableConfigurationProperties({AemConfiguration.class,AemProxyConfiguration.class}) diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AutoConfigurationTest.java b/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AutoConfigurationTest.java index 42ec67dd..1d1bf50e 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AutoConfigurationTest.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AutoConfigurationTest.java @@ -4,32 +4,47 @@ import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.Test; +import org.mockito.Mockito; import org.springframework.boot.autoconfigure.AutoConfigurations; +import org.springframework.boot.autoconfigure.web.client.RestClientSsl; import org.springframework.boot.test.context.assertj.AssertableApplicationContext; import org.springframework.boot.test.context.assertj.AssertableWebApplicationContext; import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.boot.test.context.runner.ContextConsumer; import org.springframework.boot.test.context.runner.WebApplicationContextRunner; -import org.springframework.boot.autoconfigure.jersey.ResourceConfigCustomizer; +import org.springframework.context.annotation.Bean; +import org.springframework.web.client.RestClient; import com._4point.aem.fluentforms.api.output.OutputService; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitAemProxyProcessor; -import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitLocalProcessor; import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmissionHandler; -import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitProcessor; +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.AfSubmitLocalProcessor; +import com._4point.aem.fluentforms.spring.AemProxyAfSubmission.SpringAfSubmitProcessor; /** - * Test that AutoCOnfiguration happens. The code in this test class is based on the following docs: + * Test that AutoConfiguration happens. The code in this test class is based on the following docs: * * https://spring.io/blog/2018/03/07/testing-auto-configurations-with-spring-boot-2-0 * */ class AutoConfigurationTest { - private static final AutoConfigurations AUTO_CONFIG = AutoConfigurations.of(FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class); + /** + * This class provides mock versions of beans that would normally be provided by Spring Boot in a real application. We + * only need to mock out the RestClient.Builder and RestClientSsl beans because those are the only Spring Boot provided + * beans that our AutoConfigurations depend on. + */ + private static class SpringBootMocks { + @Bean RestClient.Builder mockRestClientBuilder() { return Mockito.mock(RestClient.Builder.class, Mockito.RETURNS_DEEP_STUBS); } + @Bean private RestClientSsl mockRestClientSsl() { return Mockito.mock(RestClientSsl.class); } + } + + private static final AutoConfigurations AUTO_CONFIG = AutoConfigurations.of(FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class, SpringBootMocks.class); - private static final AutoConfigurations LOCAL_SUBMIT_CONFIG = AutoConfigurations.of(FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class, DummyLocalSubmitHandler.class); + private static final AutoConfigurations LOCAL_SUBMIT_CONFIG = AutoConfigurations.of(FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class, DummyLocalSubmitHandler.class, SpringBootMocks.class); + private static final AutoConfigurations ALTERNATE_PROXY_CONFIG = AutoConfigurations.of(DummyProxyImplementation.class, FluentFormsAutoConfiguration.class, AemProxyAutoConfiguration.class, SpringBootMocks.class); + // Tests to make sure that only the FluentFormsLibraries are loaded in a non-web application. private static final ContextConsumer FF_LIBRARIES_ONLY = (context) -> { assertAll( @@ -38,8 +53,7 @@ class AutoConfigurationTest { ()->assertThat(context).hasSingleBean(OutputService.class), ()->assertThat(context).getBean("outputService").isNotNull(), ()->assertThat(context).doesNotHaveBean(AemProxyAutoConfiguration.class), - ()->assertThat(context).doesNotHaveBean(ResourceConfigCustomizer.class), - ()->assertThat(context).doesNotHaveBean(AfSubmitProcessor.class), + ()->assertThat(context).doesNotHaveBean(SpringAfSubmitProcessor.class), ()->assertThat(context).doesNotHaveBean(AfSubmissionHandler.class) ); }; @@ -52,8 +66,7 @@ class AutoConfigurationTest { ()->assertThat(context).hasSingleBean(OutputService.class), ()->assertThat(context).getBean("outputService").isNotNull(), ()->assertThat(context).doesNotHaveBean(AemProxyAutoConfiguration.class), - ()->assertThat(context).doesNotHaveBean(ResourceConfigCustomizer.class), - ()->assertThat(context).doesNotHaveBean(AfSubmitProcessor.class), + ()->assertThat(context).doesNotHaveBean(SpringAfSubmitProcessor.class), ()->assertThat(context).doesNotHaveBean(AfSubmissionHandler.class) ); }; @@ -67,10 +80,8 @@ class AutoConfigurationTest { ()->assertThat(context).getBean("outputService").isNotNull(), ()->assertThat(context).hasSingleBean(AemProxyAutoConfiguration.class), ()->assertThat(context).getBean(AemProxyAutoConfiguration.class.getName()).isSameAs(context.getBean(AemProxyAutoConfiguration.class)), - ()->assertThat(context).hasSingleBean(ResourceConfigCustomizer.class), - ()->assertThat(context).getBean("afProxyConfigurer").isNotNull(), - ()->assertThat(context).hasSingleBean(AfSubmitProcessor.class), - ()->assertThat(context).getBean(AfSubmitProcessor.class).isSameAs(context.getBean(AfSubmitAemProxyProcessor.class)), + ()->assertThat(context).hasSingleBean(SpringAfSubmitProcessor.class), + ()->assertThat(context).getBean(SpringAfSubmitProcessor.class).isSameAs(context.getBean(AfSubmitAemProxyProcessor.class)), ()->assertThat(context).doesNotHaveBean(AfSubmissionHandler.class) ); }; @@ -84,10 +95,8 @@ class AutoConfigurationTest { ()->assertThat(context).getBean("outputService").isNotNull(), ()->assertThat(context).hasSingleBean(AemProxyAutoConfiguration.class), ()->assertThat(context).getBean(AemProxyAutoConfiguration.class.getName()).isSameAs(context.getBean(AemProxyAutoConfiguration.class)), - ()->assertThat(context).hasSingleBean(ResourceConfigCustomizer.class), - ()->assertThat(context).getBean("afProxyConfigurer").isNotNull(), - ()->assertThat(context).hasSingleBean(AfSubmitProcessor.class), - ()->assertThat(context).getBean(AfSubmitProcessor.class).isSameAs(context.getBean(AfSubmitLocalProcessor.class)), + ()->assertThat(context).hasSingleBean(SpringAfSubmitProcessor.class), + ()->assertThat(context).getBean(SpringAfSubmitProcessor.class).isSameAs(context.getBean(AfSubmitLocalProcessor.class)), ()->assertThat(context).hasSingleBean(AfSubmissionHandler.class) ); }; @@ -101,6 +110,9 @@ class AutoConfigurationTest { private final WebApplicationContextRunner webLocalSubmitContextRunner = new WebApplicationContextRunner() .withConfiguration(LOCAL_SUBMIT_CONFIG); + private final WebApplicationContextRunner webAlternateProxyContextRunner = new WebApplicationContextRunner() + .withConfiguration(ALTERNATE_PROXY_CONFIG); + // Only the services that do not require a web server should be started. @Test void nonWebContext_StartNonWebServices() { @@ -158,6 +170,35 @@ void webContext_StartAllServices_LocalSubmit() { .run(WEB_LOCAL_SUBMIT_SERVICES); } + // Only the FluentForms libraries are instantiated by this autoconfiguration when an alternate proxy implementation is supplied. + @Test + void webContext_StartAllServices_AlternateProxySupplied() { + this.webAlternateProxyContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password") + .run(WEB_FF_LIBRARIES_ONLY); + } + + // Only the FluentForms libraries are instantiated when an alternate proxy tyoe is configured. + @Test + void webContext_ProxyDisabled_AlternateProxyConfigured() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password", + "fluentforms.rproxy.type=someothertype") + .run(WEB_FF_LIBRARIES_ONLY); + } + + // All services should start when the default proxy type is configured. + @Test + void webContext_ProxyEnabled_DefaultProxyConfigured() { + this.webContextRunner + .withPropertyValues("fluentforms.aem.servername=localhost", "fluentforms.aem.port=4502", + "fluentforms.aem.user=user", "fluentforms.aem.password=password", + "fluentforms.rproxy.type=springmvc") + .run(WEB_ALL_DEFAULT_SERVICES); + } + public static class DummyLocalSubmitHandler implements AfSubmissionHandler { @@ -171,4 +212,8 @@ public SubmitResponse processSubmission(Submission submission) { return null; } } + + public static class DummyProxyImplementation implements AemProxyImplemention { + + } } diff --git a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/FluentFormsAutoConfigurationTest.java b/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/FluentFormsAutoConfigurationTest.java index 40f981a2..56309a3e 100644 --- a/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/FluentFormsAutoConfigurationTest.java +++ b/spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/FluentFormsAutoConfigurationTest.java @@ -23,7 +23,6 @@ import com._4point.aem.docservices.rest_services.client.helpers.AemConfig; import com._4point.aem.docservices.rest_services.client.helpers.Builder.RestClientFactory; import com._4point.aem.docservices.rest_services.client.html5.Html5FormsService; -import com._4point.aem.docservices.rest_services.client.jersey.JerseyRestClient; import com._4point.aem.fluentforms.api.DocumentFactory; import com._4point.aem.fluentforms.api.assembler.AssemblerService; import com._4point.aem.fluentforms.api.convertPdf.ConvertPdfService; @@ -97,7 +96,7 @@ void testDocumentFactory(@Autowired DocumentFactory factory) { @Test void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); - assertTrue(client instanceof JerseyRestClient, "RestClientFactory should return a JerseyRestClient by default"); + assertTrue(client instanceof SpringRestClientRestClient, "RestClientFactory should return a SpringRestClientRestClient by default"); } @Test @@ -193,23 +192,24 @@ void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemC } } - @SpringBootTest(classes = {com._4point.aem.fluentforms.spring.FluentFormsAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, - properties = { - "fluentforms.aem.servername=localhost", - "fluentforms.aem.port=4502", - "fluentforms.aem.user=admin", - "fluentforms.aem.password=admin", - "fluentforms.aem.usessl=true", - "fluentforms.restclient=jersey" // Configure for Jersey RestClient - }) - public static class JserseyRestClient_SslNoBundleNameTest { - - @Test - void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { - RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); - assertTrue(client instanceof JerseyRestClient, "RestClientFactory should return a JerseyRestClient when configured to do so"); - } - } +// @Disabled("Needs to be moved to the Jersey Rest Client module") +// @SpringBootTest(classes = {com._4point.aem.fluentforms.spring.FluentFormsAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, +// properties = { +// "fluentforms.aem.servername=localhost", +// "fluentforms.aem.port=4502", +// "fluentforms.aem.user=admin", +// "fluentforms.aem.password=admin", +// "fluentforms.aem.usessl=true", +// "fluentforms.restclient=jersey" // Configure for Jersey RestClient +// }) +// public static class JserseyRestClient_SslNoBundleNameTest { +// +// @Test +// void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { +// RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); +// assertTrue(client instanceof JerseyRestClient, "RestClientFactory should return a JerseyRestClient when configured to do so"); +// } +// } @SpringBootTest(classes = {com._4point.aem.fluentforms.spring.FluentFormsAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, properties = { @@ -232,26 +232,28 @@ void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemC } } - @SpringBootTest(classes = {com._4point.aem.fluentforms.spring.FluentFormsAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, - properties = { - "fluentforms.aem.servername=localhost", - "fluentforms.aem.port=4502", - "fluentforms.aem.user=admin", - "fluentforms.aem.password=admin", - "fluentforms.aem.usessl=true", - "spring.ssl.bundle.jks.aem.truststore.location=file:src/test/resources/aemforms.p12", - "spring.ssl.bundle.jks.aem.truststore.password=Pa$$123", - "spring.ssl.bundle.jks.aem.truststore.type=PKCS12", - "fluentforms.restclient=jersey" // Configure for Jersey RestClient - }) - public static class JserseyRestClient_SslBundleTest { - - @Test - void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { - RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); - assertTrue(client instanceof JerseyRestClient, "RestClientFactory should return a JerseyRestClient when configured to do so"); - } - } +// @Disabled("This test needs to be moved to the Jersey autoconfiguration project when it is created.") +// @SpringBootTest(classes = {com._4point.aem.fluentforms.spring.FluentFormsAutoConfigurationTest.TestApplication.class, FluentFormsAutoConfiguration.class}, +// properties = { +// "fluentforms.aem.servername=localhost", +// "fluentforms.aem.port=4502", +// "fluentforms.aem.user=admin", +// "fluentforms.aem.password=admin", +// "fluentforms.aem.usessl=true", +// "spring.ssl.bundle.jks.aem.truststore.location=file:src/test/resources/aemforms.p12", +// "spring.ssl.bundle.jks.aem.truststore.password=Pa$$123", +// "spring.ssl.bundle.jks.aem.truststore.type=PKCS12", +// "fluentforms.restclient=jersey" // Configure for Jersey RestClient +// }) +// public static class JserseyRestClient_SslBundleTest { +// +// @Test +// void testRestClientFactory(@Autowired RestClientFactory factory, @Autowired AemConfiguration config) { +// RestClient client = factory.apply(toAemConfig(config) , "testRestClientFactory", ()->"correlationId"); +// assertTrue(client instanceof JerseyRestClient, "RestClientFactory should return a JerseyRestClient when configured to do so"); +// } +// } + private static AemConfig toAemConfig(AemConfiguration config) { return new AemConfig() { diff --git a/spring/fluentforms-spring-boot-starter/pom.xml b/spring/fluentforms-spring-boot-starter/pom.xml index fa2086be..f91e248f 100644 --- a/spring/fluentforms-spring-boot-starter/pom.xml +++ b/spring/fluentforms-spring-boot-starter/pom.xml @@ -6,7 +6,7 @@ org.springframework.boot spring-boot-starter-parent - 3.5.5 + 3.5.7 fluentforms-spring-boot-starter diff --git a/spring/pom.xml b/spring/pom.xml new file mode 100644 index 00000000..01466dc9 --- /dev/null +++ b/spring/pom.xml @@ -0,0 +1,41 @@ + + 4.0.0 + com._4point.aem.fluentforms + spring-starters + pom + 0.0.4-SNAPSHOT + Fluent Forms Spring Boot Starter Projects + + + + fluentforms-spring-boot-autoconfigure + fluentforms-spring-boot-starter + fluentforms-sample-webmvc-app + fluentforms-sample-cli-app + + fluentforms-jersey-spring-boot-autoconfigure + fluentforms-jersey-spring-boot-starter + fluentforms-sample-web-jersey-app + + + + + + + maven-install-plugin + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + + + + \ No newline at end of file